smoodly 0.0.27 → 0.0.29

package/dist/admin/ui/theme.js

@@ -671,6 +671,13 @@ body:has(.sm-admin){margin:0}
 .sm-cell--title{font-weight:500}
 .sm-cell--grip{overflow:visible;display:flex;align-items:center;margin-left:-4px}
 .sm-empty{padding:28px 8px;color:var(--text-muted)}
+/* Settings › Content health (spec 2026-09-27 editor safety §4): headed sections of grouped rows. */
+.sm-health section+section{margin-top:24px}
+.sm-health__section{font-size:var(--text-sm);font-weight:600;letter-spacing:var(--caps-tracking);text-transform:var(--caps-transform);color:var(--text-muted);margin:0 0 8px;padding:0 8px}
+.sm-health__group{display:flex;flex-direction:column;gap:2px;margin-bottom:16px}
+.sm-health__group > .sm-btn{align-self:flex-start;margin-top:4px}
+.sm-health__headline{display:flex;justify-content:space-between;gap:12px;font-weight:600;padding:6px 8px;margin:0}
+.sm-health__row{grid-template-columns:minmax(160px,1fr) 140px 90px 120px 70px}
 /* ── drag and drop (spec 2026-09-09 §7) ─────────────────────────────── */
 /* The grip is faint until its row is hovered or it has focus. */
 .sm-grip{
@@ -795,6 +802,12 @@ body:has(.sm-admin){margin:0}
   font-family:var(--font-sans);font-size:var(--text-xs);font-weight:600;letter-spacing:var(--tracking-tag);text-transform:uppercase;color:var(--text-muted);
 }
 .sm-stale{padding:8px 20px 0}
+/* Drift (spec 2026-09-27 editor safety §5): the document notice under the stale line, the orphan group at a form's foot. */
+.sm-drift{padding:8px 20px 0}
+.sm-orphans{margin-top:16px;border-top:1px solid var(--line);padding-top:12px}
+.sm-orphans__head{cursor:pointer;font-size:var(--text-sm);font-weight:600;letter-spacing:var(--caps-tracking);text-transform:var(--caps-transform);color:var(--text-muted)}
+.sm-orphans__row{display:grid;grid-template-columns:minmax(80px,auto) 1fr auto auto;gap:8px;align-items:center;margin-top:8px}
+.sm-orphans__value{color:var(--text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:var(--font-mono);font-size:var(--text-sm)}
 .sm-lock{display:inline-flex;align-items:center;margin-left:6px;color:var(--text-muted);vertical-align:middle}
 .sm-presence{margin:0;padding:6px 20px 0;font-size:13px;color:var(--text-muted)}
 .sm-banner{
@@ -922,6 +935,14 @@ body:has(.sm-admin){margin:0}
 .sm-outline-row__label{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
 .sm-outline-row__note{font-size:var(--text-sm);font-weight:500;flex:none;letter-spacing:var(--caps-tracking);text-transform:var(--caps-transform)}
 .sm-outline-row__add{color:var(--accent);font-weight:500;flex:none}
+/* Drift marks (spec 2026-09-27 editor safety §5): a stripe inside the row's left edge, red for broken, muted for left over. */
+.sm-outline-row--broken{box-shadow:inset 3px 0 0 var(--danger)}
+.sm-outline-row--orphan{box-shadow:inset 3px 0 0 var(--line-dashed)}
+.sm-outline-note{margin:0;font-size:var(--text-sm);color:var(--danger)}
+/* A removed zone's one row wraps its sentence rather than cutting it: the inspector is narrow. */
+.sm-outline-row--removed{height:auto;min-height:var(--outline-row-h);padding-block:6px}
+.sm-outline-row--removed .sm-outline-row__label{white-space:normal}
+.sm-rtcard--broken{box-shadow:inset 3px 0 0 var(--danger)}
 /* A row with a grip: the grip takes the left padding's place and the label follows it. */
 .sm-outline-row--grip{padding-left:2px}
 .sm-outline-row--grip .sm-outline-row__label{flex:1}
@@ -943,12 +964,17 @@ body:has(.sm-admin){margin:0}
   width:26px;height:26px;flex:none;border-radius:var(--radius-sm);background:var(--accent-soft);
   color:var(--accent);display:grid;place-items:center;font-size:13px;
 }
-/* Combobox (spec 2026-09-17 §1): the input owns the width, the list hangs under it. */
+/* Combobox (spec 2026-09-17 §1): the input owns the width, the list hangs under it —
+   portaled and fixed at the input's width (--combo-w), above modals and below
+   the confirm scrim (2026-09-27); inline under the input in static markup. */
 .sm-combo{position:relative}
 .sm-combo .sm-input{width:100%;padding-right:30px}
+.sm-combo--suffix .sm-input{padding-right:96px}
+.sm-combo__suffix{position:absolute;right:28px;top:50%;transform:translateY(-50%);display:flex;align-items:center;gap:4px}
+.sm-combo__suffix a.sm-iconbtn{text-decoration:none}
 .sm-combo__chevron{position:absolute;right:10px;top:50%;transform:translateY(-50%);pointer-events:none;color:var(--text-muted)}
 .sm-combo__list{position:absolute;top:calc(100% + 4px);left:0;right:0;width:auto;max-height:280px;overflow-y:auto;z-index:60}
-.sm-combo__list--up{top:auto;bottom:calc(100% + 4px)}
+.sm-combo__list--floating{position:fixed;top:auto;right:auto;width:var(--combo-w,300px);z-index:75}
 .sm-combo__empty{padding:8px 10px;color:var(--text-muted);font-size:var(--text-sm)}
 /* Reference picker (spec 2026-09-17 §2): the picked entries under the search input. */
 .sm-refpicker{display:flex;flex-direction:column;gap:6px;min-width:0}
@@ -978,7 +1004,7 @@ body:has(.sm-admin){margin:0}
 .sm-combo--tag{width:180px}
 .sm-combo--tag .sm-input{height:var(--control-h-sm);padding-right:10px}
 .sm-combo--tag .sm-combo__chevron{display:none}
-.sm-combo--tag .sm-combo__list{right:auto;width:240px}
+.sm-combo__list.sm-combo__list--tag{right:auto;width:240px}
 /* ── date and datetime pickers (spec 2026-09-25) ──────────────────────
    The text box with a calendar button as its suffix; for datetime an hour
    and a minute select beside it; the popover a month grid on the menu
@@ -1152,6 +1178,9 @@ body:has(.sm-admin){margin:0}
 }
 .sm-dialog__context strong{font-weight:500;color:var(--text);flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;font-size:var(--text-md)}
 .sm-dialog__context code{font-family:var(--font-mono);flex:none}
+.sm-confirm__option{margin-top:4px;font-size:var(--text-md);color:var(--text)}
+.sm-redirects-from{display:flex;flex-direction:column;gap:4px}
+.sm-redirects-from code{font-size:var(--text-sm)}
 /* A form dialog's fields: white fields on the white card get the tile tone instead. */
 .sm-dialog__form{display:flex;flex-direction:column;gap:14px}
 .sm-dialog__form .sm-input,.sm-dialog__form .sm-select,.sm-dialog__form .sm-inputwrap{background:var(--surface)}

package/dist/admin/validate.js

@@ -5,7 +5,6 @@
 // A field whose `.hidden()` condition holds is skipped entirely — a hidden
 // required field is not required (spec 2026-09-14 §12); the same isHidden
 // the form uses decides, over the same scope.
-import { optionValues } from "../fields.js";
 import { isHidden } from "../conditions.js";
 import { cssProblem } from "../css.js";
 import { normalizeTag, sameTag } from "../tags.js";
@@ -13,6 +12,7 @@ import { hasContent } from "./richtext-doc.js";
 import { ELEMENT_NODE, richtextBlocks } from "../richtext-walk.js";
 import { rowsProblems } from "../custom/rows.js";
 import { isCalendarDay, isInstant } from "./forms/date-picker.js";
+import { fits, misfitMessage } from "./drift.js";
 const subfields = (d) => d.fields && typeof d.fields === "object" ? d.fields : {};
 const itemOf = (d) => d.item && typeof d.item === "object" ? d.item : undefined;
 const isEmpty = (v) => v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0);
@@ -32,6 +32,11 @@ function validateValue(path, value, d, errors, elements, scope) {
             errors.push({ field: path, message: "Required." });
         return;
     }
+    // The one type check (spec 2026-09-27 editor safety §2): drift and publish share it.
+    if (!fits(d, value)) {
+        errors.push({ field: path, message: misfitMessage(d, value) });
+        return;
+    }
     if (d.type === "richtext") {
         if (!hasContent(value)) {
             if (!mayBeAbsent(d))
@@ -58,26 +63,20 @@ function validateValue(path, value, d, errors, elements, scope) {
     }
     // Dates (spec 2026-09-25 date pickers §2): the stored formats exactly, and a day the calendar has.
     if (d.type === "date") {
-        if (typeof value !== "string" || !isCalendarDay(value))
+        if (!isCalendarDay(value))
             errors.push({ field: path, message: "Not a date (2026-09-02)." });
         return;
     }
     if (d.type === "datetime") {
-        if (typeof value !== "string" || !isInstant(value))
+        if (!isInstant(value))
             errors.push({ field: path, message: "Not a date and time." });
         return;
     }
-    if (d.type === "image" || d.type === "video" || d.type === "file") {
-        if (typeof value !== "object" || Array.isArray(value) || typeof value.asset !== "string") {
-            errors.push({ field: path, message: "Must be an uploaded file." });
-        }
+    if (d.type === "image" || d.type === "video" || d.type === "file")
         return;
-    }
     if (d.type === "list") {
-        if (!Array.isArray(value)) {
-            errors.push({ field: path, message: "Must be a list." });
+        if (!Array.isArray(value))
             return;
-        }
         if (typeof d.min === "number" && value.length < d.min)
             errors.push({ field: path, message: `At least ${plural(d.min, "item")}.` });
         if (typeof d.max === "number" && value.length > d.max)
@@ -89,37 +88,19 @@ function validateValue(path, value, d, errors, elements, scope) {
         return;
     }
     if (d.type === "object") {
-        if (typeof value !== "object" || Array.isArray(value)) {
-            errors.push({ field: path, message: "Must be an object." });
-            return;
-        }
         validateMap(path, value, subfields(d), errors, elements, { ...scope, self: value });
         return;
     }
-    if (d.type === "boolean") {
-        if (typeof value !== "boolean")
-            errors.push({ field: path, message: "Must be on or off." });
-        return;
-    }
-    if (d.type === "select" || d.type === "radio") {
-        const allowed = optionValues(d.options);
-        if (allowed.length > 0 && !allowed.includes(value)) {
-            errors.push({ field: path, message: `Must be one of: ${allowed.join(", ")}.` });
-        }
+    // The shape of these is fits' (above); what is left is the count.
+    if (d.type === "boolean" || d.type === "select" || d.type === "radio" || d.type === "checkboxes")
         return;
-    }
     // Refs (spec 2026-09-17 §3): the shape and the count. Whether a target exists
     // and is published is publish integrity's question (store.ts), not this one's.
-    if (d.type === "ref") {
-        if (typeof value !== "string")
-            errors.push({ field: path, message: "Must be an entry." });
+    if (d.type === "ref")
         return;
-    }
     if (d.type === "refList") {
-        if (!Array.isArray(value) || value.some((v) => typeof v !== "string" || v === "")) {
-            errors.push({ field: path, message: "Must be a list of entries." });
+        if (!Array.isArray(value))
             return;
-        }
         if (typeof d.min === "number" && value.length < d.min)
             errors.push({ field: path, message: `At least ${plural(d.min, "item")}.` });
         if (typeof d.max === "number" && value.length > d.max)
@@ -130,10 +111,8 @@ function validateValue(path, value, d, errors, elements, scope) {
         return;
     }
     if (d.type === "tags") {
-        if (!Array.isArray(value)) {
-            errors.push({ field: path, message: "Must be a list of tags." });
+        if (!Array.isArray(value))
             return;
-        }
         if (typeof d.min === "number" && value.length < d.min)
             errors.push({ field: path, message: `At least ${plural(d.min, "item")}.` });
         if (typeof d.max === "number" && value.length > d.max)
@@ -146,17 +125,6 @@ function validateValue(path, value, d, errors, elements, scope) {
         });
         return;
     }
-    if (d.type === "checkboxes") {
-        if (!Array.isArray(value)) {
-            errors.push({ field: path, message: "Must be a list." });
-            return;
-        }
-        const allowed = optionValues(d.options);
-        if (value.some((v) => !allowed.includes(v))) {
-            errors.push({ field: path, message: `Must be one of: ${allowed.join(", ")}.` });
-        }
-        return;
-    }
     if (typeof d.max === "number" && typeof value === "string" && value.length > d.max) {
         errors.push({ field: path, message: `Must be at most ${d.max} characters.` });
     }

package/dist/entry-store.d.ts

@@ -2,9 +2,9 @@ import type { CollectionSchema, EntryOrder } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
-import { type PathIndex } from "./path-index.ts";
+import { type PathHit, type PathIndex } from "./path-index.ts";
 import { type DraftToken } from "./draft-token.ts";
-import { type LocaleSet, type PathTarget } from "./paths.ts";
+import { type LocaleSet } from "./paths.ts";
 export type EntryLocale = {
     /** The entry's segment in this locale; null claims no URL. */
     slug: string | null;
@@ -40,6 +40,12 @@ export type EntryVersion = {
     /** When the content last changed: the unpublished draft row is rewritten in place (spec 2026-09-13 history §1). */
     savedAt: number;
 };
+/** One entry row for the drift scan (spec 2026-09-27 editor safety §3), whatever its collection:
+ *  locale → the live version's merged fields, null where the locale is not published. */
+export type EntryScan = {
+    record: EntryRecord;
+    live: Record<string, Record<string, unknown> | null>;
+};
 export type EntryUsage = {
     sourceKind: string;
     sourceId: string;
@@ -96,6 +102,8 @@ export interface EntryStore {
     create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions, by?: string): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
+    /** Every entry row, registered collection or not, with each published locale's live fields (spec 2026-09-27 editor safety §3). */
+    scanEntries(): Promise<EntryScan[]>;
     /** Batched read for the resolver: the MERGED fields in `locale`, keyed
      * by id. An id that is missing, absent in the locale, or (with
      * `status`) unpublished there is omitted. With `{ status: "published" }`
@@ -107,7 +115,10 @@ export interface EntryStore {
     }): Promise<Record<string, Record<string, unknown>>>;
     /** Replaces the merged fields for `locale`: shared keys on the node
      * (every locale sees them), localized keys and the slug on the row. */
-    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
+    /** `redirect` (default true) keeps a published row's old address as a redirect when the slug changes (spec 2026-09-26 redirects §1). */
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null, options?: {
+        redirect?: boolean;
+    }): Promise<EntryRecord>;
     setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     /** The live row goes back to what is published: the published snapshot's fields
      *  (shared and localized, split as on save — the slug is never versioned) written over
@@ -143,6 +154,8 @@ export interface EntryStore {
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;
+    }, options?: {
+        redirect?: boolean;
     }): Promise<EntryRecord>;
     /** Rewrite manual order to 1..N for the given ids, one batched pass. */
     reorder(collection: string, orderedIds: string[]): Promise<void>;
@@ -153,8 +166,10 @@ export interface EntryStore {
         sourceKind: string;
         sourceId: string;
     }[]>;
-    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<PathHit | null>;
     pathsOf(collection: string, id: string): Promise<Record<string, string>>;
+    /** locale → this entry's old addresses. */
+    redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
 }
 export declare function schemaOf(collections: CollectionSchema<any>[], name: string): CollectionSchema<any>;
 /** A global item is a collection with exactly one entry (spec 2026-09-07). */
@@ -196,6 +211,10 @@ export type SplitFields = {
  *  Every key that is neither localized nor `slug` is shared — declared or
  *  not — so a stray key never disappears into a locale row. */
 export declare function splitFields(fields: Record<string, unknown>, schema: CollectionSchema<any>): SplitFields;
+/** A localized key's value still in the shared fields — saved while the field was shared — stays
+ *  there as every locale's fallback: a write never deletes it (spec 2026-09-27 editor safety §7).
+ *  Reads merge shared, then the row, so each locale shows its own value once it has one. */
+export declare function keepLocalizedShared(before: Record<string, unknown>, shared: Record<string, unknown>, schema: CollectionSchema<any>): Record<string, unknown>;
 export declare function entryLocaleRow(record: EntryRecord, locale: string): EntryLocale;
 /** The merged view of one locale: shared + that locale's fields + its
  *  slug. A fresh object; throws for an absent locale. */
@@ -271,17 +290,22 @@ export declare class MemoryEntryStore implements EntryStore {
     getMany(collection: string, ids: string[], locale: string, options?: {
         status?: "published";
     }): Promise<Record<string, Record<string, unknown>>>;
-    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null, options?: {
+        redirect?: boolean;
+    }): Promise<EntryRecord>;
     setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     discardDraft(collection: string, id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions, by?: string): Promise<EntryRecord>;
     removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
+    scanEntries(): Promise<EntryScan[]>;
     listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
     restore(collection: string, id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;
+    }, options?: {
+        redirect?: boolean;
     }): Promise<EntryRecord>;
     delete(collection: string, id: string): Promise<void>;
     reorder(collection: string, orderedIds: string[]): Promise<void>;
@@ -290,6 +314,7 @@ export declare class MemoryEntryStore implements EntryStore {
         sourceKind: string;
         sourceId: string;
     }[]>;
-    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<PathHit | null>;
     pathsOf(collection: string, id: string): Promise<{}>;
+    redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
 }

package/dist/entry-store.js

@@ -13,10 +13,11 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
 import { MemoryPathIndex } from "./path-index.js";
+import { groupRedirects } from "./store.js";
 import { assertFresh } from "./draft-token.js";
 import { globalEntryId } from "./global-id.js";
 import { DEFAULT_SPACE_ID } from "./sql-space.js";
-import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, } from "./paths.js";
+import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, rewriteTargets, } from "./paths.js";
 /** The field types whose value is an array: a scalar `where` on one is
  *  containment, and any-of on one is refused by the site layer (both
  *  adapters read the text form of the whole array, never its elements). */
@@ -97,6 +98,17 @@ export function splitFields(fields, schema) {
     }
     return { shared: structuredClone(shared), localized: structuredClone(localized), slug: slugOf(fields) };
 }
+/** A localized key's value still in the shared fields — saved while the field was shared — stays
+ *  there as every locale's fallback: a write never deletes it (spec 2026-09-27 editor safety §7).
+ *  Reads merge shared, then the row, so each locale shows its own value once it has one. */
+export function keepLocalizedShared(before, shared, schema) {
+    const out = { ...shared };
+    for (const key of localizedKeys(schema)) {
+        if (key in before && !(key in out))
+            out[key] = structuredClone(before[key]);
+    }
+    return out;
+}
 export function entryLocaleRow(record, locale) {
     const row = record.locales[locale];
     if (!row)
@@ -270,8 +282,8 @@ export class MemoryEntryStore {
         }
         return sets;
     }
-    async writePaths(collection, nodes) {
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byId, this.schema(collection), this.locales));
+    async writePaths(collection, nodes, redirect = true) {
+        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byId, this.schema(collection), this.locales));
     }
     writeRefs(entry) {
         this.refs.rewrite({ sourceKind: "entry", sourceId: entry.id }, entryRefEdges(this.liveFieldSets(entry), this.schema(entry.collection), this.elements));
@@ -396,7 +408,7 @@ export class MemoryEntryStore {
         }
         return out;
     }
-    async update(collection, id, locale, fields, by, expected) {
+    async update(collection, id, locale, fields, by, expected, options) {
         const schema = this.schema(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
@@ -407,11 +419,11 @@ export class MemoryEntryStore {
             throw entryErrors.noSlug(collection);
         this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
         const before = { fields: entry.fields, row: { ...row } };
-        entry.fields = shared;
+        entry.fields = keepLocalizedShared(before.fields, shared, schema);
         row.fields = localized;
         row.slug = slug;
         try {
-            await this.writePaths(collection, this.subtree(entry));
+            await this.writePaths(collection, this.subtree(entry), options?.redirect ?? true);
         }
         catch (e) {
             entry.fields = before.fields;
@@ -448,7 +460,7 @@ export class MemoryEntryStore {
         if (!snapshot)
             throw entryErrors.nothingPublished(collection, id, locale);
         const { shared, localized } = splitFields(snapshot.fields, schema);
-        entry.fields = shared;
+        entry.fields = keepLocalizedShared(entry.fields, shared, schema);
         row.fields = localized;
         const abandoned = row.draftVersionId;
         row.draftVersionId = row.publishedVersionId;
@@ -505,7 +517,7 @@ export class MemoryEntryStore {
             throw entryErrors.localeInUse(locale, blockers);
         delete entry.locales[locale];
         try {
-            await this.writePaths(collection, [entry]);
+            await this.writePaths(collection, [entry], false);
         }
         catch (e) {
             entry.locales[locale] = row;
@@ -516,6 +528,18 @@ export class MemoryEntryStore {
         this.writeRefs(entry);
         return this.snapshot(entry);
     }
+    async scanEntries() {
+        return [...this.entries.values()].map((entry) => ({
+            record: this.snapshot(entry),
+            live: Object.fromEntries(Object.entries(entry.locales).map(([l, row]) => {
+                if (row.status !== "published")
+                    return [l, null];
+                // A legacy published row without a snapshot serves its live row (spec 2026-09-14 §1).
+                const snap = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
+                return [l, snap ? structuredClone(snap.fields) : entryFieldsIn(entry, l)];
+            })),
+        }));
+    }
     async listVersions(collection, id, locale) {
         this.must(collection, id);
         return [...this.versions.values()]
@@ -534,7 +558,7 @@ export class MemoryEntryStore {
         if (versionId === row.publishedVersionId)
             return this.discardDraft(collection, id, locale, by, expected);
         const { shared, localized } = splitFields(version.fields, schema);
-        entry.fields = shared;
+        entry.fields = keepLocalizedShared(entry.fields, shared, schema);
         row.fields = localized; // the slug is the row's own and never versioned
         this.recordVersion(entry, locale);
         this.bump(entry, row, by);
@@ -546,7 +570,7 @@ export class MemoryEntryStore {
         const v = this.versions.get(versionId);
         return v ? structuredClone(v) : null;
     }
-    async move(collection, id, to) {
+    async move(collection, id, to, options) {
         if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no tree position");
         const entry = this.must(collection, id);
@@ -572,7 +596,7 @@ export class MemoryEntryStore {
         const previous = new Map(siblings.map((s) => [s.id, s.sort]));
         siblings.forEach((s, i) => (s.sort = i + 1));
         try {
-            await this.writePaths(collection, subtree);
+            await this.writePaths(collection, subtree, options?.redirect ?? true);
         }
         catch (e) {
             Object.assign(entry, before);
@@ -621,4 +645,8 @@ export class MemoryEntryStore {
     pathsOf(collection, id) {
         return this.row(collection, id) ? this.paths.pathsOf({ kind: "entry", id }) : Promise.resolve({});
     }
+    async redirectsOf(collection, id) {
+        this.schema(collection);
+        return groupRedirects(await this.paths.redirectsOf({ kind: "entry", id }));
+    }
 }

package/dist/index.d.ts

@@ -51,7 +51,7 @@ export type { PathIndex } from "./path-index.ts";
 export { MemoryEntryStore } from "./entry-store.ts";
 export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
-export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
+export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryScan, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.ts";
 export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
@@ -60,7 +60,7 @@ export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve
 export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
 export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions, LocaleAlternate, PageAlternate } from "./paths.ts";
 export { fixedPathFor } from "./localize.ts";
-export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
+export type { PageStore, PageRecord, PageLocale, PageVersion, PageScan, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
 export type { FieldBuilder, Descriptor, ValueOf, Option, OptionInput, OptionValue } from "./fields.ts";

package/dist/next/page-renderer.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { unstable_cache } from "next/cache";
 import { draftMode } from "next/headers";
-import { notFound } from "next/navigation";
+import { notFound, permanentRedirect } from "next/navigation";
 import { connection } from "next/server";
 import { EditorBridge } from "../admin/next/bridge.js";
 import { fixedPathFor } from "../localize.js";
@@ -15,18 +15,31 @@ export function createPageRenderer(options) {
     const href = options.href ?? ((path) => path);
     const shapes = new Map(options.pages.filter((p) => p.schema.kind === "page").map((p) => [p.schema.name, p]));
     const entryPages = new Map(options.pages.filter((p) => p.schema.kind === "entryPage" && p.schema.collection).map((p) => [p.schema.collection, p]));
-    /** locate (uncached: the id it returns IS the cache tag) then load —
-     *  cached per (locale, path) outside draft mode. */
-    async function load(locale, path, draft, version) {
-        const target = await site.locate(locale, path);
-        if (!target)
-            return null;
+    /** The hit for a located target (locate is uncached: the id it returns
+     *  IS the cache tag): load — cached per (locale, path) outside draft mode. */
+    async function load(target, locale, path, draft, version) {
         if (draft)
             return site.load(target, locale, path, { draft: true, ...(version !== undefined ? { version } : {}) });
         return unstable_cache(() => site.load(target, locale, path), ["smoodly-site", locale, path], {
             tags: [target.kind === "page" ? pageTag(target.id) : entryTag(target.id)],
         })();
     }
+    /** A redirect row (spec 2026-09-26 redirects §7): the node's CURRENT path in this locale, through href, the query kept; no path there is a 404. */
+    async function redirectTo(target, locale, params) {
+        const current = (await site.targetPaths(target))[locale];
+        if (!current)
+            notFound();
+        const query = new URLSearchParams();
+        for (const [k, v] of Object.entries(params ?? {})) {
+            if (typeof v === "string")
+                query.append(k, v);
+            else
+                for (const item of v ?? [])
+                    query.append(k, item);
+        }
+        const qs = query.toString();
+        permanentRedirect(href(current, locale) + (qs ? `?${qs}` : ""));
+    }
     function render(hit, editor, locale) {
         if (hit.kind === "page") {
             const Page = shapes.get(hit.template);
@@ -67,7 +80,10 @@ export function createPageRenderer(options) {
         const editor = draft && params?.["smoodly-editor"] === "1";
         const versionParam = params?.["smoodly-version"];
         const version = draft && typeof versionParam === "string" && versionParam !== "" ? versionParam : undefined;
-        const hit = await load(locale, path, draft, version);
+        const target = await site.locate(locale, path);
+        if (target?.redirect)
+            await redirectTo(target, locale, params);
+        const hit = target ? await load(target, locale, path, draft, version) : null;
         if (!hit || !accept(hit))
             notFound();
         return (_jsxs(_Fragment, { children: [editor ? _jsx(EditorBridge, {}) : null, render(hit, editor, locale)] }));
@@ -78,7 +94,10 @@ export function createPageRenderer(options) {
         const locale = opts?.locale ?? site.locales.default;
         const path = pathFor(locale);
         const { isEnabled: draft } = await draftMode();
-        const hit = await load(locale, path, draft);
+        const target = await site.locate(locale, path);
+        if (!target || target.redirect)
+            return {};
+        const hit = await load(target, locale, path, draft);
         if (!hit || !accept(hit))
             return {};
         return { ...(hit.kind === "page" ? metadataFrom(hit.tree.meta, { title: hit.title }) : {}), ...alternates(hit) };

package/dist/path-index.d.ts

@@ -1,16 +1,40 @@
 import type { PathRow, PathTarget } from "./paths.ts";
 export type { PathRow, PathTarget } from "./paths.ts";
+/** A rewrite target; `redirectLocales` names the locales whose old live rows stay as redirects (none = drop them). */
+export type RewriteTarget = PathTarget & {
+    redirectLocales?: readonly string[];
+};
+/** What lives at an address: the target, and whether the row is a redirect to it. */
+export type PathHit = PathTarget & {
+    redirect: boolean;
+};
 export interface PathIndex {
-    rewrite(targets: PathTarget[], rows: PathRow[]): Promise<void>;
+    rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
+    /** Every row of the targets, redirects included (a deleted node has no old addresses). */
     remove(targets: PathTarget[]): Promise<void>;
-    resolve(locale: string, path: string): Promise<PathTarget | null>;
+    resolve(locale: string, path: string): Promise<PathHit | null>;
+    /** locale → the target's LIVE path. */
     pathsOf(target: PathTarget): Promise<Record<string, string>>;
+    /** The target's redirect rows. */
+    redirectsOf(target: PathTarget): Promise<PathRow[]>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    /** A redirect by hand: refused (pathLiveError) at a live address; another redirect row there is replaced. */
+    addRedirect(row: PathRow): Promise<void>;
+    /** Deletes a redirect row; a live row at the address is left alone. */
+    removeRedirect(locale: string, path: string): Promise<void>;
 }
 export declare const pathTakenError: (locale: string, path: string) => Error;
+export declare const pathLiveError: (locale: string, path: string) => Error;
 export declare class MemoryPathIndex implements PathIndex {
     private rows;
-    rewrite(targets: PathTarget[], rows: PathRow[]): Promise<void>;
+    rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
     remove(targets: PathTarget[]): Promise<void>;
-    resolve(locale: string, path: string): Promise<PathTarget | null>;
+    resolve(locale: string, path: string): Promise<PathHit | null>;
     pathsOf(target: PathTarget): Promise<Record<string, string>>;
+    redirectsOf(target: PathTarget): Promise<PathRow[]>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    addRedirect(row: PathRow): Promise<void>;
+    removeRedirect(locale: string, path: string): Promise<void>;
 }