smoodly 0.0.26 → 0.0.28

package/dist/admin/shell/redirects-list.js

@@ -0,0 +1,15 @@
+export const targetOptions = (targets) => targets.map((t) => ({ value: `${t.target.kind}:${t.target.id}`, label: `${t.title} · ${t.path}` }));
+export function parseTargetValue(value) {
+    const m = /^(page|entry):(.+)$/.exec(value);
+    return m ? { kind: m[1], id: m[2] } : null;
+}
+/** Admin-relative (the caller applies adminHref). */
+export const editorHref = (item, locale) => item.target.kind === "page"
+    ? `/pages/${encodeURIComponent(item.target.id)}?locale=${encodeURIComponent(locale)}`
+    : `/${item.collection}/${encodeURIComponent(item.target.id)}?locale=${encodeURIComponent(locale)}`;
+export const REMOVE_REDIRECT_CONFIRM = {
+    title: "Remove this redirect?",
+    body: "Visitors who open the old address get a Not found page. Browsers that already followed the redirect may keep going to the new address for a while.",
+    confirmLabel: "Remove redirect",
+    destructive: true,
+};

package/dist/admin/shell/settings.d.ts

@@ -1,9 +1,18 @@
+import { type MemberRole } from "../../permissions.ts";
 export declare const SETTINGS_PAGES: readonly [{
     readonly id: "members";
     readonly title: "Members";
+    readonly capability: "settings";
+}, {
+    readonly id: "redirects";
+    readonly title: "Redirects";
+    readonly capability: "content.write";
 }];
-export type SettingsPageId = (typeof SETTINGS_PAGES)[number]["id"];
-export declare const DEFAULT_SETTINGS_PAGE: SettingsPageId;
-/** The page for the segment after /settings: the default for none, null for an unknown one. */
+export type SettingsPage = (typeof SETTINGS_PAGES)[number];
+export type SettingsPageId = SettingsPage["id"];
+/** The pages this role may open, in nav order. Every member has content.write, so the area is never empty. */
+export declare const visibleSettingsPages: (role: MemberRole) => readonly SettingsPage[];
+export declare const defaultSettingsPage: (role: MemberRole) => SettingsPageId;
+/** The page for the segment after /settings; null for none or an unknown one. */
 export declare function settingsPage(tail: string | undefined): SettingsPageId | null;
 export declare function settingsTitle(page: SettingsPageId): string;

package/dist/admin/shell/settings.js

@@ -1,15 +1,19 @@
-// The Settings area's pages (spec 2026-09-25 §5; narrowed 2026-09-25 to
-// Members alone — Roles and API Keys dropped, see DESIGN.md §2): ids are
-// URL segments under /settings, titles are what the secondary nav and
-// each top bar show. Pure, so routing is testable without React.
+// The Settings area's pages (spec 2026-09-25 §5; Roles and API Keys
+// dropped 2026-09-25, Redirects added 2026-09-26 §6): ids are URL
+// segments under /settings, titles are what the secondary nav and each
+// top bar show, and each page names the capability that opens it —
+// Members for admins, Redirects for every member, as renaming is. Pure,
+// so routing is testable without React.
+import { can } from "../../permissions.js";
 export const SETTINGS_PAGES = [
-    { id: "members", title: "Members" },
+    { id: "members", title: "Members", capability: "settings" },
+    { id: "redirects", title: "Redirects", capability: "content.write" },
 ];
-export const DEFAULT_SETTINGS_PAGE = "members";
-/** The page for the segment after /settings: the default for none, null for an unknown one. */
+/** The pages this role may open, in nav order. Every member has content.write, so the area is never empty. */
+export const visibleSettingsPages = (role) => SETTINGS_PAGES.filter((p) => can(role, p.capability));
+export const defaultSettingsPage = (role) => visibleSettingsPages(role)[0].id;
+/** The page for the segment after /settings; null for none or an unknown one. */
 export function settingsPage(tail) {
-    if (tail === undefined)
-        return DEFAULT_SETTINGS_PAGE;
     return SETTINGS_PAGES.some((p) => p.id === tail) ? tail : null;
 }
 export function settingsTitle(page) {

package/dist/admin/ui/ConfirmDialog.d.ts

@@ -2,7 +2,7 @@ import { type ReactElement } from "react";
 import { type ConfirmOptions } from "./confirm.ts";
 export declare function ConfirmDialog({ options, onAnswer }: {
     options: ConfirmOptions;
-    onAnswer(yes: boolean): void;
+    onAnswer(yes: boolean, checked?: boolean): void;
 }): ReactElement;
 /** Renders the pending question, once, from the shell. */
 export declare function ConfirmHost(): ReactElement | null;

package/dist/admin/ui/ConfirmDialog.js

@@ -10,16 +10,17 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // <ConfirmHost/> renders the pending question from ui/confirm.ts, once,
 // from the shell; the dialog itself is a plain component so a test can
 // render it statically.
-import { useId, useSyncExternalStore } from "react";
+import { useId, useState, useSyncExternalStore } from "react";
 import { DialogCard } from "./Dialog.js";
 import { Button } from "./primitives.js";
 import { pendingConfirm, subscribeConfirm } from "./confirm.js";
 export function ConfirmDialog({ options, onAnswer }) {
-    const { title, body, confirmLabel, cancelLabel = "Cancel", destructive = false, subject } = options;
+    const { title, body, confirmLabel, cancelLabel = "Cancel", destructive = false, subject, option } = options;
+    const [checked, setChecked] = useState(option?.checked ?? false);
     const uid = useId();
     const bodyId = `sm-confirm-body${uid}`;
     const cancel = () => onAnswer(false);
-    return (_jsxs(DialogCard, { title: title, role: "alertdialog", describedBy: body ? bodyId : undefined, onClose: cancel, className: "sm-confirm", actions: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "secondary", autoFocus: destructive, onClick: cancel, children: cancelLabel }), _jsx(Button, { variant: destructive ? "destructive" : "primary", autoFocus: !destructive, onClick: () => onAnswer(true), children: confirmLabel })] }), children: [body && _jsx("p", { className: "sm-dialog__body", id: bodyId, children: body }), subject && (_jsxs("div", { className: "sm-dialog__context", children: [_jsx("strong", { children: subject.name }), subject.path && _jsx("code", { children: subject.path })] }))] }));
+    return (_jsxs(DialogCard, { title: title, role: "alertdialog", describedBy: body ? bodyId : undefined, onClose: cancel, className: "sm-confirm", actions: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "secondary", autoFocus: destructive, onClick: cancel, children: cancelLabel }), _jsx(Button, { variant: destructive ? "destructive" : "primary", autoFocus: !destructive, onClick: () => onAnswer(true, checked), children: confirmLabel })] }), children: [body && _jsx("p", { className: "sm-dialog__body", id: bodyId, children: body }), option && (_jsxs("label", { className: "sm-choice sm-confirm__option", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: (e) => setChecked(e.target.checked) }), _jsx("span", { children: option.label })] })), subject && (_jsxs("div", { className: "sm-dialog__context", children: [_jsx("strong", { children: subject.name }), subject.path && _jsx("code", { children: subject.path })] }))] }));
 }
 /** Renders the pending question, once, from the shell. */
 export function ConfirmHost() {

package/dist/admin/ui/confirm.d.ts

@@ -17,16 +17,27 @@ export type ConfirmOptions = {
     destructive?: boolean;
     /** The context chip repeating the subject; omit when there is no single subject. */
     subject?: ConfirmSubject;
+    /** A yes/no rider under the body — "Redirect the old address" (spec 2026-09-26 redirects §6); `checked` is its initial state. */
+    option?: {
+        label: string;
+        checked: boolean;
+    };
+};
+export type ConfirmAnswer = {
+    yes: boolean;
+    checked: boolean;
 };
 export type ConfirmRequest = {
     id: number;
     options: ConfirmOptions;
-    answer(yes: boolean): void;
+    answer(yes: boolean, checked?: boolean): void;
 };
 /** The Discard changes question, shared by the page editor and the entry and global forms (publish flow §4). */
 export declare const DISCARD_CONFIRM: Omit<ConfirmOptions, "subject">;
+/** Ask; resolves with the answer and the option's final state once the dialog closes. */
+export declare function confirmWithOption(options: ConfirmOptions): Promise<ConfirmAnswer>;
 /** Ask; resolves with the answer once the dialog closes. */
-export declare function confirm(options: ConfirmOptions): Promise<boolean>;
+export declare const confirm: (options: ConfirmOptions) => Promise<boolean>;
 /** The question being asked, if any — the head of the queue. */
 export declare const pendingConfirm: () => ConfirmRequest | null;
 /** For useSyncExternalStore: fires on every queue change. */

package/dist/admin/ui/confirm.js

@@ -20,29 +20,33 @@ let queue = [];
 let seq = 0;
 const notify = () => { for (const fn of listeners)
     fn(); };
-/** Ask; resolves with the answer once the dialog closes. */
-export function confirm(options) {
+/** Ask; resolves with the answer and the option's final state once the dialog closes. */
+export function confirmWithOption(options) {
+    const initial = options.option?.checked ?? false;
     if (listeners.size === 0) {
         const text = [options.title, options.body].filter(Boolean).join("\n\n");
-        return Promise.resolve(typeof window !== "undefined" && typeof window.confirm === "function" ? window.confirm(text) : false);
+        const yes = typeof window !== "undefined" && typeof window.confirm === "function" ? window.confirm(text) : false;
+        return Promise.resolve({ yes, checked: initial });
     }
     return new Promise((resolve) => {
         const id = ++seq;
         const request = {
             id,
             options,
-            answer(yes) {
+            answer(yes, checked = initial) {
                 if (!queue.some((r) => r.id === id))
                     return; // answered already
                 queue = queue.filter((r) => r.id !== id);
                 notify();
-                resolve(yes);
+                resolve({ yes, checked });
             },
         };
         queue = [...queue, request];
         notify();
     });
 }
+/** Ask; resolves with the answer once the dialog closes. */
+export const confirm = (options) => confirmWithOption(options).then((a) => a.yes);
 /** The question being asked, if any — the head of the queue. */
 export const pendingConfirm = () => queue[0] ?? null;
 /** For useSyncExternalStore: fires on every queue change. */

package/dist/admin/ui/primitives.d.ts

@@ -120,8 +120,11 @@ export declare function StatusBadge({ status }: {
     status: string;
 }): import("react").JSX.Element;
 /** The autosave indicator: a dot and one uppercase word. */
-export declare function SaveIndicator({ state }: {
+/** `pending`: an edit is waiting on the autosave debounce — shown as Saving, so "Saved" always means the
+ *  store holds what is on screen (the browser suite's `expectSaved` relies on exactly that). */
+export declare function SaveIndicator({ state, pending }: {
     state: SaveState;
+    pending?: boolean;
 }): import("react").JSX.Element;
 /** `caps`: the overline style — small, uppercase, tracked (2026-09-26; the mono face before). */
 export declare function SectionLabel({ children, action, caps, style }: {

package/dist/admin/ui/primitives.js

@@ -124,14 +124,16 @@ export function StatusBadge({ status }) {
         }, children: status }));
 }
 /** The autosave indicator: a dot and one uppercase word. */
-export function SaveIndicator({ state }) {
+/** `pending`: an edit is waiting on the autosave debounce — shown as Saving, so "Saved" always means the
+ *  store holds what is on screen (the browser suite's `expectSaved` relies on exactly that). */
+export function SaveIndicator({ state, pending = false }) {
     const map = {
         saved: { label: "Saved", dot: "var(--status-saved-dot)", color: "var(--text-muted)" },
         saving: { label: "Saving", dot: "var(--warn)", color: "var(--text-muted)" },
         error: { label: "Save failed — retrying", dot: "var(--danger)", color: "var(--danger)" },
         stale: { label: "Not saved — newer version exists", dot: "var(--danger)", color: "var(--danger)" },
     };
-    const { label, dot, color } = map[state];
+    const { label, dot, color } = map[pending && state === "saved" ? "saving" : state];
     return (_jsxs("span", { className: "sm-savestate", "data-testid": "save-status", style: { color }, title: label, children: [_jsx("span", { className: "sm-dot", style: { background: dot } }), label] }));
 }
 /** `caps`: the overline style — small, uppercase, tracked (2026-09-26; the mono face before). */

package/dist/admin/ui/theme.js

@@ -1152,6 +1152,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/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;
@@ -107,7 +107,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 +146,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 +158,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). */
@@ -271,7 +278,9 @@ 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>;
@@ -282,6 +291,8 @@ export declare class MemoryEntryStore implements EntryStore {
     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 +301,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). */
@@ -270,8 +271,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 +397,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);
@@ -411,7 +412,7 @@ export class MemoryEntryStore {
         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;
@@ -505,7 +506,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;
@@ -546,7 +547,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 +573,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 +622,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/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>;
 }

package/dist/path-index.js

@@ -1,12 +1,27 @@
 const sameTarget = (a, b) => a.kind === b.kind && a.id === b.id;
 const key = (locale, path) => `${locale} ${path}`;
 export const pathTakenError = (locale, path) => new Error(`smoodly: the path "${path}" (${locale}) is already taken.`);
+export const pathLiveError = (locale, path) => new Error(`smoodly: "${path}" (${locale}) is a live address.`);
+const strip = ({ redirect: _redirect, ...row }) => row;
 export class MemoryPathIndex {
     constructor() {
         this.rows = [];
     }
     async rewrite(targets, rows) {
-        const kept = this.rows.filter((r) => !targets.some((t) => sameTarget(t, r)));
+        const ofTarget = (r) => targets.find((t) => sameTarget(t, r));
+        const newKeys = new Set(rows.map((r) => key(r.locale, r.path)));
+        // 1. redirect rows at the new live addresses go, whoever they point at (live wins, rename-back reclaims)
+        let kept = this.rows.filter((r) => !(r.redirect && newKeys.has(key(r.locale, r.path))));
+        // 2. the targets' old live rows: flipped to redirects in the named locales unless the address stays live
+        kept = kept.map((r) => {
+            const t = !r.redirect ? ofTarget(r) : undefined;
+            return t && t.redirectLocales?.includes(r.locale) && !newKeys.has(key(r.locale, r.path)) ? { ...r, redirect: true } : r;
+        });
+        // 3. the targets' remaining live rows go — and so do their redirect rows in a locale the
+        //    target has no new live row in (a removed translation: nothing could resolve them)
+        const liveLocales = new Set(rows.map((r) => `${r.kind} ${r.id} ${r.locale}`));
+        kept = kept.filter((r) => !ofTarget(r) || (r.redirect && liveLocales.has(`${r.kind} ${r.id} ${r.locale}`)));
+        // 4. the new live rows: a collision now is with another target's live row
         const taken = new Set(kept.map((r) => key(r.locale, r.path)));
         for (const row of rows) {
             const k = key(row.locale, row.path);
@@ -14,20 +29,38 @@ export class MemoryPathIndex {
                 throw pathTakenError(row.locale, row.path);
             taken.add(k);
         }
-        this.rows = [...kept, ...rows.map((r) => ({ ...r }))];
+        this.rows = [...kept, ...rows.map((r) => ({ ...r, redirect: false }))];
     }
     async remove(targets) {
         this.rows = this.rows.filter((r) => !targets.some((t) => sameTarget(t, r)));
     }
     async resolve(locale, path) {
         const row = this.rows.find((r) => r.locale === locale && r.path === path);
-        return row ? { kind: row.kind, id: row.id } : null;
+        return row ? { kind: row.kind, id: row.id, redirect: row.redirect } : null;
     }
     async pathsOf(target) {
         const out = {};
         for (const r of this.rows)
-            if (sameTarget(r, target))
+            if (!r.redirect && sameTarget(r, target))
                 out[r.locale] = r.path;
         return out;
     }
+    async redirectsOf(target) {
+        return this.rows.filter((r) => r.redirect && sameTarget(r, target)).map(strip);
+    }
+    async listLive(locale) {
+        return this.rows.filter((r) => !r.redirect && r.locale === locale).map(strip);
+    }
+    async listRedirects(locale) {
+        return this.rows.filter((r) => r.redirect && r.locale === locale).map(strip);
+    }
+    async addRedirect(row) {
+        const existing = this.rows.find((r) => r.locale === row.locale && r.path === row.path);
+        if (existing && !existing.redirect)
+            throw pathLiveError(row.locale, row.path);
+        this.rows = [...this.rows.filter((r) => r !== existing), { ...row, redirect: true }];
+    }
+    async removeRedirect(locale, path) {
+        this.rows = this.rows.filter((r) => !(r.redirect && r.locale === locale && r.path === path));
+    }
 }

package/dist/paths.d.ts

@@ -91,6 +91,22 @@ export declare function entrySegment(entry: EntryLike, locale: string): string |
 export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
     path?: string | Record<string, string>;
 }, set: LocaleSet): PathRow[];
+/** The locales a node is published in — the ones whose old addresses may
+ *  stay as redirects (spec 2026-09-26 redirects §2: only published rows). */
+export declare function publishedLocales(node: {
+    locales: Record<string, {
+        status: "draft" | "published";
+    }>;
+}): string[];
+/** The rewrite targets for a subtree: with `redirect`, each names its published locales. */
+export declare function rewriteTargets<T extends {
+    id: string;
+    locales: Record<string, {
+        status: "draft" | "published";
+    }>;
+}>(kind: "page" | "entry", nodes: T[], redirect: boolean): (PathTarget & {
+    redirectLocales?: string[];
+})[];
 /** A target's address in one locale (spec 2026-09-15 §1). A page always
  *  has both; an entry's slug is null when its row claims no URL, and its
  *  path null then or when the collection has no `path`. */

package/dist/paths.js

@@ -130,6 +130,15 @@ export function entryPathRows(targets, byId, collection, set) {
     }
     return rows;
 }
+/** The locales a node is published in — the ones whose old addresses may
+ *  stay as redirects (spec 2026-09-26 redirects §2: only published rows). */
+export function publishedLocales(node) {
+    return Object.keys(node.locales).filter((l) => node.locales[l].status === "published");
+}
+/** The rewrite targets for a subtree: with `redirect`, each names its published locales. */
+export function rewriteTargets(kind, nodes, redirect) {
+    return nodes.map((n) => (redirect ? { kind, id: n.id, redirectLocales: publishedLocales(n) } : { kind, id: n.id }));
+}
 /** The page's address in EVERY supported locale, in config order: null
  *  where the node is absent, where an ancestor is, or where `advertised`
  *  says no — the site passes "published, or draft mode", so an

package/dist/schema-version.d.ts

@@ -1,7 +1,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_VERSION = 4;
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const CORE_FILE_RE: RegExp;
 export declare const VIEWS_FILE_RE: RegExp;

package/dist/schema-version.js

@@ -7,7 +7,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 4;
 export const SCHEMA_VERSION_KEY = "schema_version";
 export const CORE_FILE_RE = /^(\d{14})_smoodly_v(\d+)\.sql$/;
 export const VIEWS_FILE_RE = /^(\d{14})_smoodly_views\.sql$/;