smoodly 0.0.27 → 0.0.28

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 = 3;
+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 = 3;
+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$/;

package/dist/site.d.ts

@@ -9,6 +9,7 @@ import { type GlobalSchema } from "./global.ts";
 import { type StyleValues, type StyleValuesInput } from "./styles.ts";
 import { type CustomConfigInput, type ResolvedCustom } from "./custom/index.ts";
 import type { PageRecord, PageStore } from "./store.ts";
+import type { PathHit } from "./path-index.ts";
 export type SiteOptions = {
     stores: () => {
         pages: PageStore;
@@ -106,7 +107,9 @@ export interface SmoodlySite {
     /** The custom section's resolved options the renderer hands renderPage. */
     readonly custom: ResolvedCustom;
     /** One index hit: what lives at (locale, path). Uncached by design — the id it returns is the cache tag. */
-    locate(locale: string, path: string): Promise<PathTarget | null>;
+    locate(locale: string, path: string): Promise<PathHit | null>;
+    /** locale → the target's current live path — where a redirect row sends the visitor (spec 2026-09-26 redirects §7). */
+    targetPaths(target: PathTarget): Promise<Record<string, string>>;
     /** Everything the renderer needs for one target: null when it is a folder, unpublished (outside draft), or gone. */
     load(target: PathTarget, locale: string, path: string, options?: LoadOptions): Promise<SiteHit | null>;
     resolve(locale: string, path: string, options?: LoadOptions): Promise<SiteHit | null>;

package/dist/site.js

@@ -325,13 +325,15 @@ export function createSmoodlySite(options) {
         styles,
         custom,
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
+        targetPaths: (target) => options.stores().pages.targetPaths(target),
         load(target, locale, path, opts = {}) {
             const draft = opts.draft ?? false;
             return target.kind === "page" ? loadPage(target.id, locale, path, draft, opts.version) : loadEntry(target.id, locale, path, draft);
         },
         async resolve(locale, path, opts) {
+            // The content API stays strict (§7): a content address is not a redirect.
             const target = await site.locate(locale, path);
-            return target ? site.load(target, locale, path, opts) : null;
+            return target && !target.redirect ? site.load(target, locale, path, opts) : null;
         },
         ...api,
     };

package/dist/sql.js

@@ -235,12 +235,16 @@ create table if not exists "refs" (
 -- and no page or entry can share a URL with another in any locale.
 -- Rows exist for drafts too (the editor needs them); the read policy
 -- admits a row only when its target is published.
+-- A row with "redirect" set is an old address of its target (spec
+-- 2026-09-26 redirects §2): the same primary key, so a redirect can never
+-- sit where a live URL is and a live row taking the address replaces it.
 create table if not exists "paths" (
   ${SPACE_COL},
   "locale" text not null,
   "path" text not null,
   "kind" text not null check ("kind" in ('page', 'entry')),
   "target_id" uuid not null,
+  "redirect" boolean not null default false,
   primary key ("space_id", "locale", "path")
 );
 
@@ -280,10 +284,24 @@ create index if not exists "assets_space_created_idx"
 -- function runs in the caller's transaction, so a primary-key collision
 -- rolls the whole rewrite back. Inserted rows get their space from the
 -- a_set_space trigger (the claim, or the default space).
+-- A target may name redirect_locales: its old live rows there stay as redirects.
 create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql set search_path = public as $$
   delete from "paths" p
-  using jsonb_to_recordset(p_targets) as t(kind text, id uuid)
+  using jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
+  where p."redirect" and p."locale" = r.locale and p."path" = r.path
+    and p."space_id" = "smoodly_current_space"();
+  update "paths" p set "redirect" = true
+  from jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
+  where not p."redirect" and p."kind" = t.kind and p."target_id" = t.id
+    and p."locale" = any (coalesce(t.redirect_locales, '{}'::text[]))
+    and not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
+                    where r.locale = p."locale" and r.path = p."path")
+    and p."space_id" = "smoodly_current_space"();
+  delete from "paths" p
+  using jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
   where p."kind" = t.kind and p."target_id" = t.id
+    and (not p."redirect" or not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
+                                          where r.kind = p."kind" and r.id = p."target_id" and r.locale = p."locale"))
     and p."space_id" = "smoodly_current_space"();
   insert into "paths" ("locale", "path", "kind", "target_id")
   select r.locale, r.path, r.kind, r.id

package/dist/store.d.ts

@@ -3,7 +3,7 @@ import type { EntryStore } from "./entry-store.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import type { Toolset } from "./toolset.ts";
 import type { MemoryRefIndex } from "./ref-index.ts";
-import { type PathIndex } from "./path-index.ts";
+import { type PathHit, type PathIndex, type PathRow } from "./path-index.ts";
 import { type DraftToken } from "./draft-token.ts";
 import { type LocaleSet, type PagePathOptions, type PathTarget } from "./paths.ts";
 export type PageLocale = {
@@ -56,21 +56,32 @@ export interface PageStore {
     createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
-    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<PathHit | null>;
     /** The database's schema version from `smoodly_meta`; null when the table is missing (older than v1). Memory: always current (spec 2026-09-26 §5). */
     schemaVersion(): Promise<number | null>;
     /** locale → path, for the locales the page exists in. */
     pathsOf(id: string): Promise<Record<string, string>>;
+    /** locale → the target's live path, for any page or entry — the renderer's redirect branch (spec 2026-09-26 redirects §7). */
+    targetPaths(target: PathTarget): Promise<Record<string, string>>;
+    /** locale → this page's old addresses. */
+    redirectsOf(id: string): Promise<Record<string, string[]>>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    addRedirect(row: PathRow): Promise<void>;
+    removeRedirect(locale: string, path: string): Promise<void>;
     /** Refused when the page already has the locale or its parent lacks it (the parent rule). */
     addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     /** Deletes the row, its versions and its paths. Refused while a
      *  descendant has the locale, and for the page's last locale. */
     removeLocale(id: string, locale: string): Promise<PageRecord>;
+    /** `redirect` (default true) keeps a published row's old address as a redirect (spec 2026-09-26 redirects §1). */
     rename(id: string, patch: {
         locale: string;
         slug?: string;
         title?: string;
-    }, by?: string): Promise<PageRecord>;
+    }, by?: string, options?: {
+        redirect?: boolean;
+    }): Promise<PageRecord>;
     /**
      * Reparents `id` under `to.parentId`. `to.index` is the moved node's
      * final 0-based position among the destination siblings: the node is
@@ -81,6 +92,8 @@ export interface PageStore {
     move(id: string, to: {
         parentId: string | null;
         index?: number;
+    }, options?: {
+        redirect?: boolean;
     }): Promise<PageRecord>;
     /** A folder becomes a page: an empty draft version per present locale. */
     setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
@@ -128,6 +141,8 @@ export type PageStoreOptions = {
 };
 export declare const DEFAULT_LOCALES: LocaleSet;
 /** The section list every adapter walks refs with: the registered ones plus the custom section's schema (spec 2026-09-14 §6). */
+/** Group an index's redirect rows by locale, paths sorted. */
+export declare function groupRedirects(rows: PathRow[]): Record<string, string[]>;
 export declare function refSections(options: PageStoreOptions): SectionLike[] | undefined;
 /** The options every adapter resolves the same way. */
 export declare function pathOptions(options: PageStoreOptions): PagePathOptions & {
@@ -198,19 +213,29 @@ export declare class MemoryPageStore implements PageStore {
     createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
-    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<PathHit | null>;
     schemaVersion(): Promise<number>;
     pathsOf(id: string): Promise<Record<string, string>>;
+    targetPaths(target: PathTarget): Promise<Record<string, string>>;
+    redirectsOf(id: string): Promise<Record<string, string[]>>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    addRedirect(row: PathRow): Promise<void>;
+    removeRedirect(locale: string, path: string): Promise<void>;
     addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
         title?: string;
-    }, by?: string): Promise<PageRecord>;
+    }, by?: string, options?: {
+        redirect?: boolean;
+    }): Promise<PageRecord>;
     move(id: string, to: {
         parentId: string | null;
         index?: number;
+    }, options?: {
+        redirect?: boolean;
     }): Promise<PageRecord>;
     setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
     saveDraft(id: string, locale: string, tree: PageTree, by?: string, expected?: DraftToken | null): Promise<PageVersion>;

package/dist/store.js

@@ -15,9 +15,19 @@ import { customToolset, withCustomSchema } from "./custom/index.js";
 import { MemoryPathIndex } from "./path-index.js";
 import { assertFresh } from "./draft-token.js";
 import { SCHEMA_VERSION } from "./schema-version.js";
-import { assertDepth, assertSegment, assertSupportedLocale, chainOf, isHomeNode, pagePathRows, unsupportedLocale, } from "./paths.js";
+import { assertDepth, assertSegment, assertSupportedLocale, chainOf, isHomeNode, pagePathRows, unsupportedLocale, rewriteTargets, } from "./paths.js";
 export const DEFAULT_LOCALES = { default: "en", supported: ["en"] };
 /** The section list every adapter walks refs with: the registered ones plus the custom section's schema (spec 2026-09-14 §6). */
+/** Group an index's redirect rows by locale, paths sorted. */
+export function groupRedirects(rows) {
+    var _a;
+    const out = {};
+    for (const r of rows)
+        (out[_a = r.locale] ?? (out[_a] = [])).push(r.path);
+    for (const l of Object.keys(out))
+        out[l].sort();
+    return out;
+}
 export function refSections(options) {
     return options.sections ? withCustomSchema(options.sections, customToolset(options.custom?.toolset)) : undefined;
 }
@@ -158,8 +168,8 @@ export class MemoryPageStore {
         walk(id);
         return out;
     }
-    async writePaths(nodes) {
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "page", id: n.id })), pagePathRows(nodes, this.byId, this.opts));
+    async writePaths(nodes, redirect = true) {
+        await this.paths.rewrite(rewriteTargets("page", nodes, redirect), pagePathRows(nodes, this.byId, this.opts));
     }
     /** Every locale's draft and published trees, deduped by version id. */
     liveTrees(page) {
@@ -282,6 +292,12 @@ export class MemoryPageStore {
     pathsOf(id) {
         return this.paths.pathsOf({ kind: "page", id });
     }
+    targetPaths(target) { return this.paths.pathsOf(target); }
+    async redirectsOf(id) { return groupRedirects(await this.paths.redirectsOf({ kind: "page", id })); }
+    listLive(locale) { return this.paths.listLive(locale); }
+    listRedirects(locale) { return this.paths.listRedirects(locale); }
+    addRedirect(row) { return this.paths.addRedirect(row); }
+    removeRedirect(locale, path) { return this.paths.removeRedirect(locale, path); }
     async addLocale(id, locale, options, by) {
         assertSupportedLocale(locale, this.opts.locales);
         const page = this.must(id);
@@ -333,7 +349,7 @@ export class MemoryPageStore {
             throw pageErrors.localeInUse(locale, blockers.map((b) => b.locales[locale].title));
         delete page.locales[locale];
         try {
-            await this.writePaths([page]);
+            await this.writePaths([page], false);
         }
         catch (e) {
             page.locales[locale] = removed;
@@ -343,7 +359,7 @@ export class MemoryPageStore {
         this.writeRefs(page);
         return this.snapshot(page);
     }
-    async rename(id, patch, by) {
+    async rename(id, patch, by, options) {
         const page = this.must(id);
         const row = localeRow(page, patch.locale);
         if (patch.slug !== undefined)
@@ -366,7 +382,7 @@ export class MemoryPageStore {
         if (patch.title !== undefined)
             row.title = patch.title;
         try {
-            await this.writePaths(this.subtree(id));
+            await this.writePaths(this.subtree(id), options?.redirect ?? true);
         }
         catch (e) {
             Object.assign(row, before);
@@ -375,7 +391,7 @@ export class MemoryPageStore {
         touchRow(row, by);
         return this.snapshot(page);
     }
-    async move(id, to) {
+    async move(id, to, options) {
         const page = this.must(id);
         if (to.parentId !== null) {
             const parent = this.must(to.parentId);
@@ -409,7 +425,7 @@ export class MemoryPageStore {
         const previousSort = new Map(siblings.map((s) => [s.id, s.sort]));
         siblings.forEach((s, i) => (s.sort = i + 1));
         try {
-            await this.writePaths(this.subtree(id));
+            await this.writePaths(this.subtree(id), options?.redirect ?? true);
         }
         catch (e) {
             Object.assign(page, before);

package/dist/supabase-entry-store.d.ts

@@ -61,7 +61,9 @@ export declare class SupabaseEntryStore 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>;
@@ -72,10 +74,13 @@ export declare class SupabaseEntryStore 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>;
-    resolvePath(locale: string, path: string): Promise<import("./paths.ts").PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<import("./path-index.ts").PathHit | null>;
     pathsOf(collection: string, id: string): Promise<Record<string, string>>;
+    redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
     reorder(collection: string, orderedIds: string[]): Promise<void>;
     incoming(targetId: string): Promise<{
         sourceKind: string;