smoodly 0.0.33 → 0.0.35

package/dist/store.js

@@ -31,12 +31,17 @@ export function groupRedirects(rows) {
 export function refSections(options) {
     return options.sections ? withCustomSchema(options.sections, customToolset(options.custom?.toolset)) : undefined;
 }
+/** The anchors a store's own index reads when none is shared (spec 2026-09-29 anchored paths §2). */
+export function storeAnchors(options) {
+    return { addresses: options.addresses ?? {}, homePageSlug: options.homePageSlug ?? "home", defaultLocale: (options.locales ?? DEFAULT_LOCALES).default };
+}
 /** The options every adapter resolves the same way. */
 export function pathOptions(options) {
     return {
         locales: options.locales ?? DEFAULT_LOCALES,
         homePageSlug: options.homePageSlug ?? "home",
         depth: options.tree?.depth ?? 1,
+        addresses: options.addresses,
     };
 }
 /** Shared write-side rules, so both adapters throw the same messages. */
@@ -57,6 +62,8 @@ export const pageErrors = {
     localeInUse: (locale, titles) => new Error(`smoodly: child pages still exist in locale "${locale}" — remove it from ${titles.map((t) => `"${t}"`).join(", ")} first.`),
     moveLocales: (locale) => new Error(`smoodly: the destination parent does not exist in locale "${locale}" — the page cannot move under it.`),
     foreignVersion: (id, locale, versionId) => new Error(`smoodly: "${versionId}" is not a version of page "${id}" in locale "${locale}".`),
+    fixedTaken: (key) => new Error(`smoodly: a page owned by "${key}" already exists.`),
+    fixedAtRoot: () => new Error("smoodly: a code-owned page is a root record."),
 };
 export { assertSupportedLocale } from "./paths.js";
 /** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
@@ -121,8 +128,9 @@ export class MemoryPageStore {
         this.seq = new Map();
         this.byId = (id) => this.pages.get(id);
         this.options = { ...options, sections: refSections(options) };
-        this.paths = options.paths ?? new MemoryPathIndex();
         this.opts = pathOptions(options);
+        // Alone, the store's own index reads the addresses it was given (spec 2026-09-29 anchored paths §2).
+        this.paths = options.paths ?? new MemoryPathIndex(storeAnchors(options));
     }
     must(id) {
         const page = this.pages.get(id);
@@ -149,9 +157,11 @@ export class MemoryPageStore {
             .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id));
     }
     /** Sibling slugs are unique per parent PER LOCALE — a friendlier error
-     *  than the path index's, which stays the real invariant. */
+     *  than the path index's, which stays the real invariant. Code-owned
+     *  roots are left out: their path is their address, and the path index
+     *  guards it (spec 2026-09-29 nested paths §3). */
     assertSlugFree(parentId, locale, slug, except) {
-        if (this.siblings(parentId, except).some((p) => p.locales[locale]?.slug === slug))
+        if (this.siblings(parentId, except).some((p) => !p.fixed && p.locales[locale]?.slug === slug))
             throw pageErrors.slugTaken(slug);
     }
     subtree(id) {
@@ -229,6 +239,12 @@ export class MemoryPageStore {
         assertSupportedLocale(input.locale, this.opts.locales);
         assertSegment(input.slug, "page slug");
         const parentId = input.parentId ?? null;
+        if (input.fixed !== undefined) {
+            if (parentId !== null)
+                throw pageErrors.fixedAtRoot();
+            if ([...this.pages.values()].some((p) => p.fixed === input.fixed))
+                throw pageErrors.fixedTaken(input.fixed);
+        }
         if (parentId !== null) {
             const parent = this.must(parentId);
             if (this.isHome(parent))
@@ -237,7 +253,8 @@ export class MemoryPageStore {
                 throw pageErrors.parentNotInLocale(input.locale);
             assertDepth(chainOf(parent, this.byId).length + 1, this.opts.depth, "the page");
         }
-        this.assertSlugFree(parentId, input.locale, input.slug);
+        if (input.fixed === undefined)
+            this.assertSlugFree(parentId, input.locale, input.slug);
         const id = uid();
         const version = input.template === null ? null : this.newVersion(id, input.locale, { zones: {} });
         const page = {
@@ -247,6 +264,7 @@ export class MemoryPageStore {
             // An ordering hint, not a unique key: duplicates are possible after
             // moves/deletes, and the creation-order tie-break settles them.
             sort: this.siblings(parentId).length + 1,
+            fixed: input.fixed ?? null,
             locales: {
                 [input.locale]: {
                     slug: input.slug,
@@ -317,7 +335,8 @@ export class MemoryPageStore {
             assertSegment(slug, `page slug (${locale})`);
         if (page.parentId !== null && !this.must(page.parentId).locales[locale])
             throw pageErrors.parentNotInLocale(locale);
-        this.assertSlugFree(page.parentId, locale, slug, id);
+        if (!page.fixed)
+            this.assertSlugFree(page.parentId, locale, slug, id);
         // The SOURCE'S DRAFT is the copy: what the editor sees on screen when
         // they add the locale (spec §3). A folder has no tree to copy.
         const version = page.template === null
@@ -382,7 +401,7 @@ export class MemoryPageStore {
             this.hasChildren(id)) {
             throw pageErrors.homeChildren();
         }
-        if (patch.slug !== undefined)
+        if (patch.slug !== undefined && !page.fixed)
             this.assertSlugFree(page.parentId, patch.locale, patch.slug, id);
         const before = { ...row };
         if (patch.slug !== undefined)
@@ -401,6 +420,8 @@ export class MemoryPageStore {
     }
     async move(id, to, options) {
         const page = this.must(id);
+        if (page.fixed && to.parentId !== null)
+            throw pageErrors.fixedAtRoot();
         if (to.parentId !== null) {
             const parent = this.must(to.parentId);
             if (to.parentId === id || chainOf(parent, this.byId).some((n) => n.id === id))

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

@@ -18,7 +18,6 @@ export declare class SupabaseEntryStore implements EntryStore {
      *  life of the client, so the PROMISE is cached and concurrent creates
      *  share one round trip; a failed lookup is not cached. */
     private space;
-    private fetchSpace;
     private fetch;
     private must;
     private siblings;

package/dist/supabase-entry-store.js

@@ -9,7 +9,9 @@
 import { collectionDepth, collectionOrder } from "./collections.js";
 import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, keepLocalizedShared, schemaOf, splitFields, } from "./entry-store.js";
 import { globalEntryId } from "./global-id.js";
+import { readCurrentSpace } from "./current-space.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
+import { anchorsFor } from "./anchors.js";
 import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
 import { assertDepth, assertSupportedLocale, entryPathRows, rewriteTargets, slugOf } from "./paths.js";
@@ -49,9 +51,10 @@ function toVersion(row) {
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
         this.db = db;
-        this.paths = options.paths ?? new SupabasePathIndex(db);
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
         this.schemas = [...collections, ...(options.globals ?? [])];
+        // Alone, the store's own index reads its collections' addresses (spec 2026-09-29 anchored paths §2).
+        this.paths = options.paths ?? new SupabasePathIndex(db, anchorsFor({ locales: this.locales, collections }));
         this.elements = options.elements;
     }
     fail(message) {
@@ -67,7 +70,7 @@ export class SupabaseEntryStore {
      *  share one round trip; a failed lookup is not cached. */
     space() {
         if (!this.spaceId) {
-            this.spaceId = this.fetchSpace().catch((e) => {
+            this.spaceId = readCurrentSpace(this.db).catch((e) => {
                 // A failed lookup is not cached: the next write retries it.
                 this.spaceId = undefined;
                 throw e;
@@ -75,14 +78,6 @@ export class SupabaseEntryStore {
         }
         return this.spaceId;
     }
-    async fetchSpace() {
-        const res = await this.db.rpc("smoodly_current_space");
-        if (res.error)
-            this.fail(res.error.message);
-        if (typeof res.data !== "string")
-            this.fail("smoodly_current_space() returned no space — is the schema up to date?");
-        return res.data;
-    }
     // ── reads ──
     async fetch(collection, id) {
         if (!UUID_RE.test(id))
@@ -156,7 +151,7 @@ export class SupabaseEntryStore {
         const schema = this.schema(top.collection);
         const ancestors = await this.chain(top);
         const nodes = await this.subtree(top);
-        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
+        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema.name));
     }
     /** Every field set the site can render: each locale's live view, plus a
      *  published snapshot the draft has moved past (see entryRefEdges). */

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

@@ -1,18 +1,29 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
+import { type Anchors } from "./anchors.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 anchors;
+    /** Held by reference: the config's addresses (spec 2026-09-29 anchored paths §2). */
+    constructor(db: SupabaseClient, anchors?: Anchors);
     private fail;
+    /** Stored rows as callers see them: full URLs; a row whose anchor has no address is left out. */
+    private shown;
     rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
     remove(targets: PathTarget[]): Promise<void>;
+    /** Every row at a request URL's candidate keys, in one call, and the winner by precedence (spec §2). */
+    private lookup;
+    private hit;
     resolve(locale: string, path: string): Promise<PathHit | null>;
     private rowsOf;
+    /** A locale's rows, sorted by URL in JS: the stored path is not the URL. */
     private rowsIn;
     pathsOf(target: PathTarget): Promise<Record<string, string>>;
     redirectsOf(target: PathTarget): Promise<PathRow[]>;
     listLive(locale: string): Promise<PathRow[]>;
     listRedirects(locale: string): Promise<PathRow[]>;
+    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
     addRedirect(row: PathRow): Promise<void>;
+    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
     removeRedirect(locale: string, path: string): Promise<void>;
 }

package/dist/supabase-path-index.js

@@ -1,23 +1,40 @@
+import { candidates, fullPath, pickHit, sameUrlKeys } from "./anchors.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 });
+const COLS = "locale, anchor, path, kind, target_id, redirect";
 export class SupabasePathIndex {
-    constructor(db) {
+    /** Held by reference: the config's addresses (spec 2026-09-29 anchored paths §2). */
+    constructor(db, anchors = { addresses: {}, homePageSlug: "home", defaultLocale: "en" }) {
         this.db = db;
+        this.anchors = anchors;
     }
     fail(message) {
         throw new Error(`smoodly: ${message}`);
     }
+    /** Stored rows as callers see them: full URLs; a row whose anchor has no address is left out. */
+    shown(rows) {
+        const out = [];
+        for (const r of rows) {
+            const path = fullPath(this.anchors, r.anchor, r.path, r.locale);
+            if (path !== null)
+                out.push({ kind: r.kind, id: r.target_id, locale: r.locale, path });
+        }
+        return out;
+    }
     async rewrite(targets, rows) {
         const res = await this.db.rpc("smoodly_rewrite_paths", {
             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 })),
+            // `keys`: every stored key that yields the row's full URL (spec §2) — the SQL cannot read the config.
+            p_rows: rows.map((r) => ({
+                locale: r.locale, anchor: r.anchor ?? "", path: r.path, kind: r.kind, id: r.id,
+                keys: sameUrlKeys(this.anchors, r.locale, r.anchor ?? "", r.path),
+            })),
         });
         if (res.error) {
             if (res.error.code === UNIQUE_VIOLATION) {
-                // details: Key (space_id, locale, path)=(…, fi, /yritys) already exists.
-                const m = /\(space_id, locale, path\)=\([^,]+, ([^,]+), (.+)\) already exists/.exec(res.error.details ?? "");
-                throw m ? pathTakenError(m[1], m[2]) : pathTakenError("?", "?");
+                // details: Key (space_id, locale, anchor, path)=(…, en, collection:news, /hello) already exists.
+                const m = /\(space_id, locale, anchor, path\)=\([^,]+, ([^,]+), ([^,]*), (.*)\) already exists/.exec(res.error.details ?? "");
+                throw m ? pathTakenError(m[1], fullPath(this.anchors, m[2], m[3], m[1]) ?? m[3]) : pathTakenError("?", "?");
             }
             this.fail(res.error.message);
         }
@@ -30,24 +47,36 @@ export class SupabasePathIndex {
                 this.fail(res.error.message);
         }
     }
-    async resolve(locale, path) {
-        const res = await this.db.from("paths").select("kind, target_id, redirect").eq("locale", locale).eq("path", path).maybeSingle();
+    /** Every row at a request URL's candidate keys, in one call, and the winner by precedence (spec §2). */
+    async lookup(locale, url) {
+        const { keys, coded } = candidates(this.anchors, locale, url);
+        const res = await this.db.rpc("smoodly_resolve_path", { p_locale: locale, p_keys: keys });
         if (res.error)
             this.fail(res.error.message);
-        const row = res.data;
+        const rows = res.data;
+        return { rows, hit: pickHit(rows, keys, coded) };
+    }
+    async hit(locale, url) {
+        return (await this.lookup(locale, url)).hit;
+    }
+    async resolve(locale, path) {
+        const row = await this.hit(locale, path);
         return row ? { kind: row.kind, id: row.target_id, redirect: row.redirect } : null;
     }
     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);
+        const res = await this.db.from("paths").select(COLS).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);
+        return this.shown(res.data);
     }
+    /** A locale's rows, sorted by URL in JS: the stored path is not the URL. */
     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");
+        const res = await this.db.from("paths").select(COLS).eq("locale", locale).eq("redirect", redirect).order("anchor").order("path");
         if (res.error)
             this.fail(res.error.message);
-        return res.data.map(toRow);
+        // An editor's live row under a code address is no live URL: visitors never reach it (spec §4).
+        const rows = res.data.filter((r) => redirect || !(r.anchor === "" && candidates(this.anchors, locale, r.path).coded));
+        return this.shown(rows).sort((a, b) => a.path.localeCompare(b.path));
     }
     async pathsOf(target) {
         const out = {};
@@ -64,22 +93,30 @@ export class SupabasePathIndex {
     listRedirects(locale) {
         return this.rowsIn(locale, true);
     }
+    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
     async addRedirect(row) {
-        const existing = await this.resolve(row.locale, row.path);
+        const { rows, hit: existing } = await this.lookup(row.locale, row.path);
         if (existing && !existing.redirect)
             throw pathLiveError(row.locale, row.path);
-        if (existing)
+        // An editor's page hidden under a code address still holds its row: a redirect never stacks on it.
+        if (rows.some((r) => !r.redirect && r.anchor === "" && r.path === row.path))
+            throw pathLiveError(row.locale, row.path);
+        // Every redirect the URL reaches goes, under any anchor: the new one replaces them all.
+        if (rows.some((r) => r.redirect))
             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 });
+        const res = await this.db.from("paths").insert({ locale: row.locale, anchor: "", 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);
         }
     }
+    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
     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);
+        for (const k of candidates(this.anchors, locale, path).keys) {
+            const res = await this.db.from("paths").delete().eq("locale", locale).eq("anchor", k.anchor).eq("path", k.path).eq("redirect", true);
+            if (res.error)
+                this.fail(res.error.message);
+        }
     }
 }

package/dist/supabase-store.d.ts

@@ -17,6 +17,8 @@ export declare class SupabasePageStore implements PageStore {
     /** A one-row existence check — the shape `deletePage` needs too. */
     private hasChildren;
     private siblings;
+    /** Code-owned roots are left out: their path is their address, and the
+     *  path index guards it (spec 2026-09-29 nested paths §3). */
     private assertSlugFree;
     /** The node's ancestors (root first, node last), by walking parent_id. */
     private chain;

package/dist/supabase-store.js

@@ -6,7 +6,7 @@
 // are two indexed lookups. Every read embeds the locale rows
 // (`*, page_locales(*)`) so a record arrives whole. Path rows are
 // rewritten through ONE RPC per write, so a collision rolls back.
-import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, } from "./store.js";
+import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, storeAnchors, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { SCHEMA_VERSION_KEY, schemaBehind, schemaBehindMessage } from "./schema-version.js";
 import { groupRedirects } from "./store.js";
@@ -33,6 +33,7 @@ function toRecord(row) {
         id: row.id,
         parentId: row.parent_id,
         template: row.template,
+        fixed: row.fixed ?? null,
         sort: row.sort === null ? null : Number(row.sort),
         locales,
     };
@@ -47,8 +48,9 @@ export class SupabasePageStore {
         /** The site's one warning per process (spec 2026-09-26 §5): fired by the first locate, never blocking. */
         this.schemaChecked = false;
         this.options = { ...options, sections: refSections(options) };
-        this.paths = options.paths ?? new SupabasePathIndex(db);
         this.opts = pathOptions(options);
+        // Alone, the store's own index reads the addresses it was given (spec 2026-09-29 anchored paths §2).
+        this.paths = options.paths ?? new SupabasePathIndex(db, storeAnchors(options));
     }
     fail(message) {
         throw new Error(`smoodly: ${message}`);
@@ -89,8 +91,10 @@ export class SupabasePageStore {
             this.fail(res.error.message);
         return res.data.map(toRecord).filter((p) => p.id !== except);
     }
+    /** Code-owned roots are left out: their path is their address, and the
+     *  path index guards it (spec 2026-09-29 nested paths §3). */
     async assertSlugFree(parentId, locale, slug, except) {
-        if ((await this.siblings(parentId, except)).some((s) => s.locales[locale]?.slug === slug))
+        if ((await this.siblings(parentId, except)).some((s) => !s.fixed && s.locales[locale]?.slug === slug))
             throw pageErrors.slugTaken(slug);
     }
     /** The node's ancestors (root first, node last), by walking parent_id. */
@@ -286,6 +290,15 @@ export class SupabasePageStore {
         assertSupportedLocale(input.locale, this.opts.locales);
         assertSegment(input.slug, "page slug");
         const parentId = input.parentId ?? null;
+        if (input.fixed !== undefined) {
+            if (parentId !== null)
+                throw pageErrors.fixedAtRoot();
+            const owned = await this.db.from("pages").select("id").eq("fixed", input.fixed).limit(1);
+            if (owned.error)
+                this.fail(owned.error.message);
+            if (owned.data.length > 0)
+                throw pageErrors.fixedTaken(input.fixed);
+        }
         if (parentId !== null) {
             const parent = await this.must(parentId);
             if (this.isHome(parent))
@@ -295,15 +308,20 @@ export class SupabasePageStore {
             assertDepth((await this.chain(parent)).length + 1, this.opts.depth, "the page");
         }
         const siblings = await this.siblings(parentId);
-        if (siblings.some((s) => s.locales[input.locale]?.slug === input.slug))
+        if (input.fixed === undefined && siblings.some((s) => !s.fixed && s.locales[input.locale]?.slug === input.slug)) {
             throw pageErrors.slugTaken(input.slug);
+        }
         const inserted = await this.db
             .from("pages")
-            .insert({ parent_id: parentId, template: input.template, sort: siblings.length + 1 })
+            .insert({ parent_id: parentId, template: input.template, sort: siblings.length + 1, fixed: input.fixed ?? null })
             .select("id")
             .single();
-        if (inserted.error)
+        if (inserted.error) {
+            // A racing materializer inserted the owner first: the unique index is the backstop.
+            if (inserted.error.code === UNIQUE_VIOLATION && input.fixed !== undefined)
+                throw pageErrors.fixedTaken(input.fixed);
             this.fail(inserted.error.message);
+        }
         const id = inserted.data.id;
         try {
             const version = input.template === null ? null : await this.insertVersion(id, input.locale, { zones: {} });
@@ -403,7 +421,8 @@ export class SupabasePageStore {
             assertSegment(slug, `page slug (${locale})`);
         if (page.parentId !== null && !(await this.must(page.parentId)).locales[locale])
             throw pageErrors.parentNotInLocale(locale);
-        await this.assertSlugFree(page.parentId, locale, slug, id);
+        if (!page.fixed)
+            await this.assertSlugFree(page.parentId, locale, slug, id);
         let added;
         try {
             // The SOURCE'S DRAFT is the copy (spec §3); a folder has no tree.
@@ -456,7 +475,7 @@ export class SupabasePageStore {
             (await this.hasChildren(id))) {
             throw pageErrors.homeChildren();
         }
-        if (patch.slug !== undefined)
+        if (patch.slug !== undefined && !page.fixed)
             await this.assertSlugFree(page.parentId, patch.locale, patch.slug, id);
         const columns = {};
         if (patch.slug !== undefined)
@@ -476,6 +495,8 @@ export class SupabasePageStore {
     }
     async move(id, to, options) {
         const page = await this.must(id);
+        if (page.fixed && to.parentId !== null)
+            throw pageErrors.fixedAtRoot();
         const subtree = await this.subtree(page);
         if (to.parentId !== null) {
             if (to.parentId === id || subtree.some((n) => n.id === to.parentId))
@@ -504,7 +525,7 @@ export class SupabasePageStore {
         const siblings = await this.siblings(to.parentId, id);
         if (to.parentId !== page.parentId) {
             for (const [locale, row] of Object.entries(page.locales)) {
-                if (siblings.some((s) => s.locales[locale]?.slug === row.slug))
+                if (siblings.some((s) => !s.fixed && s.locales[locale]?.slug === row.slug))
                     throw pageErrors.slugTaken(row.slug);
             }
         }

package/migrations/20260929120000_smoodly_v5.sql

@@ -0,0 +1,56 @@
+-- Smoodly core schema, version 5 (docs/superpowers/specs/2026-09-29-nested-collection-paths-design.md,
+-- docs/superpowers/specs/2026-09-29-anchored-paths-design.md).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 4: `pages.fixed` names the registration that owns a
+-- code-owned record, unique per space; `paths.anchor` names the code address
+-- a URL row hangs under, and the row keeps only the part editors made.
+-- No backfill: a record without `fixed` is an editor's page, a row without
+-- an anchor is the editors' tree.
+
+set client_min_messages = warning;
+
+alter table "pages" add column if not exists "fixed" text;
+
+create unique index if not exists "pages_fixed_idx"
+  on "pages" ("space_id", "fixed") where "fixed" is not null;
+
+alter table "paths" add column if not exists "anchor" text not null default '';
+alter table "paths" drop constraint if exists "paths_pkey";
+alter table "paths" add constraint "paths_pkey" primary key ("space_id", "locale", "anchor", "path");
+
+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_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
+  where p."redirect" and p."locale" = r.locale
+    and exists (select 1 from jsonb_to_recordset(r.keys) as k(anchor text, path text) where k.anchor = p."anchor" and k.path = p."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, anchor text, path text, kind text, id uuid, keys jsonb)
+                    cross join lateral jsonb_to_recordset(r.keys) as k(anchor text, path text)
+                    where r.locale = p."locale" and k.anchor = p."anchor" and k.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, anchor 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", "anchor", "path", "kind", "target_id")
+  select r.locale, r.anchor, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid);
+$$;
+
+revoke execute on function "smoodly_rewrite_paths"(jsonb, jsonb) from public, anon;
+
+create or replace function "smoodly_resolve_path"(p_locale text, p_keys jsonb) returns setof "paths" language sql stable set search_path = public as $$
+  select p.* from "paths" p
+  join jsonb_to_recordset(p_keys) as k(anchor text, path text) on p."anchor" = k.anchor and p."path" = k.path
+  where p."locale" = p_locale;
+$$;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '5')
+  on conflict ("key") do update set "value" = excluded."value";