smoodly 0.0.26 → 0.0.28

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-space.d.ts

@@ -15,3 +15,9 @@ export declare function spaceLayerSQL(): string;
  *  Schema-qualified calls: storage policies do not run with public on
  *  the search path. Last in the migration, after the functions exist. */
 export declare function storageSQL(): string;
+/** The three mutation RPCs are the stores' verbs, never a browser's (spec
+ *  2026-09-26 security pass §2): executable by the service role and by
+ *  `authenticated` (the role a cloud write key carries), not by anon or
+ *  public. `smoodly_current_space` is NOT here — the stores read it through
+ *  rpc(). Last in the schema, after every definition exists. */
+export declare function grantsSQL(): string;

package/dist/sql-space.js

@@ -25,7 +25,7 @@ export function currentSpaceSQL() {
 -- default space in self-host (service role, anon key). Policies, the
 -- insert trigger and the reorder RPC all read this ONE function.
 create or replace function "smoodly_current_space"() returns uuid
-language sql stable as $$
+language sql stable set search_path = '' as $$
   select coalesce((auth.jwt() ->> 'space_id')::uuid, ${DEFAULT_SPACE});
 $$;`.trim();
 }
@@ -90,7 +90,7 @@ alter table "spaces" enable row level security;
 -- ── Claim readers. The two lookups run as definer so they can read the
 -- service-role-only tables from inside a policy; search_path is pinned.
 create or replace function "smoodly_key_kind"() returns text
-language sql stable as $$
+language sql stable set search_path = '' as $$
   select auth.jwt() ->> 'kind';
 $$;
 
@@ -107,12 +107,25 @@ language sql stable security definer set search_path = public as $$
   select c."row_cap" from "spaces" c where c."space_id" = "smoodly_current_space"();
 $$;
 
+-- The presence gate (spec 2026-09-26 security pass §1): the caller is a
+-- member of the space the Realtime topic names. auth.uid() is the session
+-- token's subject — the anon key and a read key carry none, so a visitor
+-- is refused at join. Definer, because members has no read policy for
+-- anyone but a write key. No space claim is read: the same rule serves
+-- the cloud once the content project accepts smoodly.io's tokens (OQ 32).
+create or replace function "smoodly_presence_member"() returns boolean
+language sql stable security definer set search_path = public as $$
+  select exists (select 1 from "members" m
+    where m."user_id" = auth.uid()
+      and realtime.topic() = 'space:' || m."space_id"::text);
+$$;
+
 -- ── Triggers. A key's claim wins over whatever the insert said, so an
 -- adapter never has to know its space and cannot write into another.
 -- No claim (service role, anon) leaves the given or default value —
 -- that is how smoodly.io writes cloud-state rows for a chosen space.
 create or replace function "smoodly_set_space"() returns trigger
-language plpgsql as $$
+language plpgsql set search_path = '' as $$
 begin
   if auth.jwt() ->> 'space_id' is not null then
     new."space_id" := (auth.jwt() ->> 'space_id')::uuid;
@@ -199,17 +212,19 @@ $$;`.trim());
     statements.push(`drop policy if exists "smoodly_read" on "smoodly_meta";\n` +
         `create policy "smoodly_read" on "smoodly_meta" for select\n` +
         `  using ((select "smoodly_key_kind"()) = 'write' and not (select "smoodly_space_key_revoked"()));`);
-    // The editing-presence channel (spec 2026-09-26 concurrency §6): one
-    // private Realtime topic per space, `space:<id>`. A caller receives on
-    // and sends to its own space's topic only — the anon key resolves to the
-    // default space, a cloud read key to its claim. Identical everywhere.
-    const topic = `(select realtime.topic()) = 'space:' || (select public."smoodly_current_space"())::text`;
+    // The editing-presence channel (spec 2026-09-26 concurrency §5; gated
+    // 2026-09-26 security pass §1): one private Realtime topic per space,
+    // `space:<id>`. A caller receives on and sends to a topic only when a
+    // members row of that space names their session's user — the browser
+    // authenticates the socket with the editor's session token, never with
+    // the public key alone. Identical in self-host and the cloud.
+    const member = `(select public."smoodly_presence_member"())`;
     statements.push(`drop policy if exists "smoodly_presence_read" on "realtime"."messages";\n` +
         `create policy "smoodly_presence_read" on "realtime"."messages" for select\n` +
-        `  using (${topic});`);
+        `  using (${member});`);
     statements.push(`drop policy if exists "smoodly_presence_write" on "realtime"."messages";\n` +
         `create policy "smoodly_presence_write" on "realtime"."messages" for insert\n` +
-        `  with check (${topic});`);
+        `  with check (${member});`);
     statements.push(storageSQL());
     return statements.join("\n\n");
 }
@@ -238,3 +253,15 @@ create policy "smoodly_media_write" on storage.objects for all
   using (${write})
   with check (${write});`.trim();
 }
+/** The three mutation RPCs are the stores' verbs, never a browser's (spec
+ *  2026-09-26 security pass §2): executable by the service role and by
+ *  `authenticated` (the role a cloud write key carries), not by anon or
+ *  public. `smoodly_current_space` is NOT here — the stores read it through
+ *  rpc(). Last in the schema, after every definition exists. */
+export function grantsSQL() {
+    return [
+        `revoke execute on function "smoodly_reorder"(text, uuid[]) from public, anon;`,
+        `revoke execute on function "smoodly_reorder_pages"(uuid[]) from public, anon;`,
+        `revoke execute on function "smoodly_rewrite_paths"(jsonb, jsonb) from public, anon;`,
+    ].join("\n");
+}

package/dist/sql.js

@@ -11,7 +11,7 @@
 // locale (spec 2026-09-06 §7); a versioned collection reads its
 // fields from the published snapshot.
 import { BUILT_IN_ORDER_FIELDS } from "./collections.js";
-import { currentSpaceSQL, SPACE_COL, spaceLayerSQL } from "./sql-space.js";
+import { currentSpaceSQL, grantsSQL, SPACE_COL, spaceLayerSQL } from "./sql-space.js";
 const snake = (s) => s.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
 const q = (s) => `"${s}"`;
 // Casts are fine in views (unlike index expressions, which must be
@@ -111,7 +111,7 @@ create table if not exists "page_locales" (
 );
 
 -- Sibling reorder for pages: same shape as smoodly_reorder for entries.
-create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql as $$
+create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql set search_path = public as $$
   update "pages" pg set "sort" = u.ord
   from unnest(p_ids) with ordinality as u(id, ord)
   where pg."id" = u.id
@@ -211,7 +211,7 @@ alter table "entry_locales" add constraint "entry_locales_draft_version_fkey"
 create or replace function "smoodly_reorder"(
   p_collection text,
   p_ids uuid[]
-) returns void language sql as $$
+) returns void language sql set search_path = public as $$
   update "entries" e set "sort" = u.ord
   from unnest(p_ids) with ordinality as u(id, ord)
   where e."id" = u.id
@@ -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).
-create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql as $$
+-- 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
@@ -318,5 +336,6 @@ alter table "assets" enable row level security;
 alter table "smoodly_meta" enable row level security;
 `.trim(),
         spaceLayerSQL(),
+        grantsSQL(),
     ].join("\n\n");
 }

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;

package/dist/supabase-entry-store.js

@@ -10,8 +10,9 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, schemaOf, splitFields, } from "./entry-store.js";
 import { globalEntryId } from "./global-id.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
+import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
-import { assertDepth, assertSupportedLocale, entryPathRows, slugOf } from "./paths.js";
+import { assertDepth, assertSupportedLocale, entryPathRows, rewriteTargets, slugOf } from "./paths.js";
 // entries.id is a Postgres uuid column: filtering on a non-UUID string
 // throws invalid_text_representation. A non-UUID id can't exist in the
 // table, so treat it the same as a missing one.
@@ -151,11 +152,11 @@ export class SupabaseEntryStore {
         return new Map(res.data.map((r) => [r.id, r.fields]));
     }
     // ── the derived indexes ──
-    async writePaths(top) {
+    async writePaths(top, redirect = true) {
         const schema = this.schema(top.collection);
         const ancestors = await this.chain(top);
         const nodes = await this.subtree(top);
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
+        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
     }
     /** Every field set the site can render: each locale's live view, plus a
      *  published snapshot the draft has moved past (see entryRefEdges). */
@@ -462,7 +463,7 @@ export class SupabaseEntryStore {
         }
         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 before = await this.must(collection, id);
         const row = entryLocaleRow(before, locale);
@@ -480,7 +481,7 @@ export class SupabaseEntryStore {
         await this.updateLocale(id, locale, { slug, fields: localized }, { by });
         const record = await this.must(collection, id);
         try {
-            await this.writePaths(record);
+            await this.writePaths(record, options?.redirect ?? true);
         }
         catch (e) {
             await this.updateNode(id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
@@ -591,7 +592,7 @@ export class SupabaseEntryStore {
         // locale until the next write, never leaked content.
         await this.deleteLocale(id, locale);
         const remaining = await this.must(collection, id);
-        await this.writePaths(remaining);
+        await this.writePaths(remaining, false);
         await this.updateNode(id, {});
         const final = await this.must(collection, id);
         await this.writeRefs(final);
@@ -639,7 +640,7 @@ export class SupabaseEntryStore {
             this.fail(res.error.message);
         return res.data ? toVersion(res.data) : 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 = await this.must(collection, id);
@@ -671,7 +672,7 @@ export class SupabaseEntryStore {
             const ordered = siblings.map((s) => s.id);
             ordered.splice(Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length), 0, id);
             await this.reorder(collection, ordered);
-            await this.writePaths(await this.must(collection, id));
+            await this.writePaths(await this.must(collection, id), options?.redirect ?? true);
         }
         catch (e) {
             await this.updateNode(id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
@@ -713,6 +714,9 @@ export class SupabaseEntryStore {
     async pathsOf(collection, id) {
         return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
     }
+    async redirectsOf(collection, id) {
+        return (await this.fetch(collection, id)) ? groupRedirects(await this.paths.redirectsOf({ kind: "entry", id })) : {};
+    }
     async reorder(collection, orderedIds) {
         if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no order");

package/dist/supabase-path-index.d.ts

@@ -1,11 +1,18 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { type PathIndex, type PathRow, type PathTarget } from "./path-index.ts";
+import { type PathHit, type PathIndex, type PathRow, type PathTarget, type RewriteTarget } from "./path-index.ts";
 export declare class SupabasePathIndex implements PathIndex {
     private db;
     constructor(db: SupabaseClient);
     private fail;
-    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>;
+    private rowsOf;
+    private rowsIn;
     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/supabase-path-index.js

@@ -1,5 +1,6 @@
-import { pathTakenError } from "./path-index.js";
+import { pathLiveError, pathTakenError } from "./path-index.js";
 const UNIQUE_VIOLATION = "23505";
+const toRow = (r) => ({ kind: r.kind, id: r.target_id, locale: r.locale, path: r.path });
 export class SupabasePathIndex {
     constructor(db) {
         this.db = db;
@@ -9,7 +10,7 @@ export class SupabasePathIndex {
     }
     async rewrite(targets, rows) {
         const res = await this.db.rpc("smoodly_rewrite_paths", {
-            p_targets: targets.map((t) => ({ kind: t.kind, id: t.id })),
+            p_targets: targets.map((t) => ({ kind: t.kind, id: t.id, ...(t.redirectLocales ? { redirect_locales: [...t.redirectLocales] } : {}) })),
             p_rows: rows.map((r) => ({ locale: r.locale, path: r.path, kind: r.kind, id: r.id })),
         });
         if (res.error) {
@@ -22,31 +23,63 @@ export class SupabasePathIndex {
         }
     }
     async remove(targets) {
-        await this.rewrite(targets, []);
+        // Every row of the targets, redirects included: a delete on the target index, not the RPC (which spares redirect rows).
+        for (const t of targets) {
+            const res = await this.db.from("paths").delete().eq("kind", t.kind).eq("target_id", t.id);
+            if (res.error)
+                this.fail(res.error.message);
+        }
     }
     async resolve(locale, path) {
-        const res = await this.db
-            .from("paths")
-            .select("kind, target_id")
-            .eq("locale", locale)
-            .eq("path", path)
-            .maybeSingle();
+        const res = await this.db.from("paths").select("kind, target_id, redirect").eq("locale", locale).eq("path", path).maybeSingle();
         if (res.error)
             this.fail(res.error.message);
         const row = res.data;
-        return row ? { kind: row.kind, id: row.target_id } : null;
+        return row ? { kind: row.kind, id: row.target_id, redirect: row.redirect } : null;
     }
-    async pathsOf(target) {
-        const res = await this.db
-            .from("paths")
-            .select("locale, path")
-            .eq("kind", target.kind)
-            .eq("target_id", target.id);
+    async rowsOf(target, redirect) {
+        const res = await this.db.from("paths").select("locale, path, kind, target_id").eq("kind", target.kind).eq("target_id", target.id).eq("redirect", redirect);
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toRow);
+    }
+    async rowsIn(locale, redirect) {
+        const res = await this.db.from("paths").select("locale, path, kind, target_id").eq("locale", locale).eq("redirect", redirect).order("path");
         if (res.error)
             this.fail(res.error.message);
+        return res.data.map(toRow);
+    }
+    async pathsOf(target) {
         const out = {};
-        for (const r of res.data)
+        for (const r of await this.rowsOf(target, false))
             out[r.locale] = r.path;
         return out;
     }
+    redirectsOf(target) {
+        return this.rowsOf(target, true);
+    }
+    listLive(locale) {
+        return this.rowsIn(locale, false);
+    }
+    listRedirects(locale) {
+        return this.rowsIn(locale, true);
+    }
+    async addRedirect(row) {
+        const existing = await this.resolve(row.locale, row.path);
+        if (existing && !existing.redirect)
+            throw pathLiveError(row.locale, row.path);
+        if (existing)
+            await this.removeRedirect(row.locale, row.path);
+        const res = await this.db.from("paths").insert({ locale: row.locale, path: row.path, kind: row.kind, target_id: row.id, redirect: true });
+        if (res.error) {
+            if (res.error.code === UNIQUE_VIOLATION)
+                throw pathLiveError(row.locale, row.path);
+            this.fail(res.error.message);
+        }
+    }
+    async removeRedirect(locale, path) {
+        const res = await this.db.from("paths").delete().eq("locale", locale).eq("path", path).eq("redirect", true);
+        if (res.error)
+            this.fail(res.error.message);
+    }
 }