smoodly 0.0.4 → 0.0.6

package/dist/resolve.js

@@ -26,12 +26,8 @@ export async function resolveTree(tree, options) {
         const schema = "schema" in s ? s.schema : s;
         return [schema.name, schema];
     }));
-    const collectionSchemas = new Map(options.collections.map((c) => [c.name, c]));
     const resolved = structuredClone(tree);
-    // every entry is fetched once; cycle cuts reuse cached ancestors
-    const cache = new Map();
-    // seed tasks from every node's ref-typed fields
-    let tasks = [];
+    const tasks = [];
     for (const nodes of Object.values(resolved.zones ?? {})) {
         for (const node of nodes) {
             const schema = sectionSchemas.get(node.type);
@@ -40,7 +36,24 @@ export async function resolveTree(tree, options) {
             collectTasks(node.fields, schema.fields, tasks);
         }
     }
-    for (let round = 0; round < maxDepth && tasks.length > 0; round++) {
+    await runResolution(tasks, { collections: options.collections, fetch: options.fetch, maxDepth });
+    return resolved;
+}
+/** One entry's fields, refs hydrated — the entry page's counterpart of
+ *  resolveTree. Same rules, same batching, same cycle cut. */
+export async function resolveFields(fields, descriptors, options) {
+    const resolved = structuredClone(fields);
+    const tasks = [];
+    collectTasks(resolved, descriptors, tasks);
+    await runResolution(tasks, { ...options, maxDepth: options.maxDepth ?? Infinity });
+    return resolved;
+}
+async function runResolution(seeds, options) {
+    const collectionSchemas = new Map(options.collections.map((c) => [c.name, c]));
+    // every entry is fetched once; cycle cuts reuse cached ancestors
+    const cache = new Map();
+    let tasks = seeds;
+    for (let round = 0; round < options.maxDepth && tasks.length > 0; round++) {
         // batch: one fetch per collection with unique uncached ids
         const wanted = new Map();
         for (const task of tasks) {
@@ -111,7 +124,6 @@ export async function resolveTree(tree, options) {
         }
         tasks = next;
     }
-    return resolved;
 }
 function collectTasks(values, descriptors, out) {
     for (const [key, d] of Object.entries(descriptors)) {

package/dist/revalidate.d.ts

@@ -1,8 +1,16 @@
 import type { EntryStore } from "./entry-store.ts";
 import type { PageStore } from "./store.ts";
-export declare function affectedPageSlugs(stores: {
+export type AffectedTargets = {
+    /** Every PUBLISHED page whose tree references the entry, directly or through other entries. */
+    pageIds: string[];
+    /** The entry itself, then every entry that references it, transitively — the entry-page cache units. */
+    entryIds: string[];
+};
+export declare const pageTag: (id: string) => string;
+export declare const entryTag: (id: string) => string;
+export declare function affectedTargets(stores: {
     pages: PageStore;
     entries: EntryStore;
 }, entryId: string, options?: {
     maxDepth?: number;
-}): Promise<string[]>;
+}): Promise<AffectedTargets>;

package/dist/revalidate.js

@@ -1,12 +1,16 @@
 // The revalidation fan-out (DESIGN.md §3): an entry changed — which
-// published pages must re-render? Walks the refs index in REVERSE
+// cached units must re-render? Walks the refs index in REVERSE
 // (entry ← entry ← page), breadth-first with a visited set so cycles
 // terminate; `maxDepth` is an optional safety valve like resolveTree's.
-// Framework-free on purpose: returns slugs, and the Next.js glue maps
-// them to `revalidateTag("page:" + slug)`.
-export async function affectedPageSlugs(stores, entryId, options = {}) {
+// Framework-free on purpose: returns ids, and the Next glue maps them to
+// cache tags (`pageTag`/`entryTag`) — by id, because slugs and paths
+// change (spec 2026-09-05 §5).
+export const pageTag = (id) => `page:${id}`;
+export const entryTag = (id) => `entry:${id}`;
+export async function affectedTargets(stores, entryId, options = {}) {
     const maxDepth = options.maxDepth ?? Infinity;
     const seen = new Set([entryId]);
+    const entryIds = [entryId];
     const pageIds = new Set();
     let frontier = [entryId];
     for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
@@ -18,17 +22,18 @@ export async function affectedPageSlugs(stores, entryId, options = {}) {
                 }
                 else if (source.sourceKind === "entry" && !seen.has(source.sourceId)) {
                     seen.add(source.sourceId);
+                    entryIds.push(source.sourceId);
                     next.push(source.sourceId);
                 }
             }
         }
         frontier = next;
     }
-    const slugs = [];
+    const published = [];
     for (const id of pageIds) {
-        const page = await stores.pages.getPageById(id);
+        const page = await stores.pages.getPage(id);
         if (page?.publishedVersionId)
-            slugs.push(page.slug);
+            published.push(id);
     }
-    return slugs;
+    return { pageIds: published, entryIds };
 }

package/dist/site.d.ts

@@ -0,0 +1,85 @@
+import type { CollectionSchema, EntryOrder } from "./collections.ts";
+import { type EntryRecord, type EntryStore } from "./entry-store.ts";
+import { type LocaleSet, type PathTarget } from "./paths.ts";
+import type { SectionLike } from "./refs.ts";
+import type { PageContext, PageLink, PageTree } from "./render.tsx";
+import type { PageRecord, PageStore } from "./store.ts";
+export type SiteOptions = {
+    stores: () => {
+        pages: PageStore;
+        entries: EntryStore;
+    };
+    collections: CollectionSchema<any>[];
+    sections: SectionLike[];
+    locales: LocaleSet;
+    homePageSlug?: string;
+};
+export type SitePage = {
+    kind: "page";
+    record: PageRecord;
+    template: string;
+    tree: PageTree;
+    title: string;
+    path: string;
+    ancestors: PageLink[];
+    children: PageLink[];
+    /** locale → path, for metadata alternates. */
+    paths: Record<string, string>;
+};
+export type SiteEntry = {
+    kind: "entry";
+    collection: string;
+    /** `fields` are localized for the requested locale with refs resolved. */
+    entry: EntryRecord;
+    path: string;
+    paths: Record<string, string>;
+};
+export type SiteHit = SitePage | SiteEntry;
+export type PageTreeItem = {
+    id: string;
+    title: string;
+    path: string;
+    hasPage: boolean;
+    children: PageTreeItem[];
+};
+export type SiteEntryItem = {
+    entry: EntryRecord;
+    path: string | null;
+};
+export type EntryTreeItem = SiteEntryItem & {
+    children: EntryTreeItem[];
+};
+export type EntryQuery = {
+    locale?: string;
+    parent?: string | null;
+    order?: EntryOrder;
+};
+export type LoadOptions = {
+    draft?: boolean;
+};
+export interface SmoodlySite {
+    readonly locales: LocaleSet;
+    readonly homePageSlug: string;
+    /** 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>;
+    /** 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>;
+    getPagesTree(options?: {
+        locale?: string;
+    }): Promise<PageTreeItem[]>;
+    getPage(pathOrId: string, options?: {
+        locale?: string;
+    }): Promise<SitePage | null>;
+    getEntries(collection: string, options?: EntryQuery): Promise<SiteEntryItem[]>;
+    getEntry(collection: string, idOrPath: string, options?: {
+        locale?: string;
+    }): Promise<SiteEntryItem | null>;
+    getEntriesTree(collection: string, options?: {
+        locale?: string;
+    }): Promise<EntryTreeItem[]>;
+}
+/** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
+ *  bound to the render locale; the default keeps CMS paths as URLs. */
+export declare function pageContextOf(hit: SitePage, toUrl?: (path: string) => string): PageContext;
+export declare function createSmoodlySite(options: SiteOptions): SmoodlySite;

package/dist/site.js

@@ -0,0 +1,164 @@
+import { schemaOf } from "./entry-store.js";
+import { localizeFields, titleFor } from "./localize.js";
+import { buildPageTree, chainOf, entryPathRows, entrySegment, localesOf, pagePath, } from "./paths.js";
+import { resolveFields, resolveTree } from "./resolve.js";
+/** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
+ *  bound to the render locale; the default keeps CMS paths as URLs. */
+export function pageContextOf(hit, toUrl = (p) => p) {
+    const withUrl = (l) => ({ ...l, url: toUrl(l.path) });
+    return {
+        id: hit.record.id,
+        title: hit.title,
+        path: hit.path,
+        url: toUrl(hit.path),
+        ancestors: hit.ancestors.map(withUrl),
+        children: hit.children.map(withUrl),
+    };
+}
+export function createSmoodlySite(options) {
+    const locales = options.locales;
+    const homePageSlug = options.homePageSlug ?? "home";
+    const pathOpts = { locales, homePageSlug };
+    const mounted = options.collections.filter((c) => c.path !== undefined);
+    const fetcher = (draft) => (collection, ids) => options.stores().entries.getMany(collection, ids, draft ? undefined : { status: "published" });
+    /** Visible to the public: folders and published pages. Draft mode sees every node. */
+    const visible = (node, draft) => draft || node.template === null || node.publishedVersionId !== null;
+    const hasPage = (node, draft) => node.template !== null && (draft || node.publishedVersionId !== null);
+    const link = (node, byId, locale, draft) => ({
+        title: titleFor(node, locale, locales),
+        path: pagePath(node, byId, locale, pathOpts),
+        hasPage: hasPage(node, draft),
+    });
+    async function loadPage(id, locale, path, draft) {
+        const { pages } = options.stores();
+        const record = await pages.getPage(id);
+        if (!record || record.template === null)
+            return null;
+        const raw = draft ? await pages.getDraftTree(id) : record.publishedVersionId ? await pages.getPublishedTree(id) : null;
+        if (!raw)
+            return null;
+        const tree = await resolveTree(raw, { sections: options.sections, collections: options.collections, fetch: fetcher(draft) });
+        const all = await pages.listPages();
+        const index = new Map(all.map((n) => [n.id, n]));
+        const byId = (x) => index.get(x);
+        const chain = chainOf(record, byId);
+        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft));
+        const children = all
+            .filter((n) => n.parentId === id && visible(n, draft) && localesOf(n, locales).includes(locale))
+            .map((n) => link(n, byId, locale, draft));
+        return {
+            kind: "page",
+            record,
+            template: record.template,
+            tree,
+            title: titleFor(record, locale, locales),
+            path,
+            ancestors,
+            children,
+            paths: await pages.pathsOf(id),
+        };
+    }
+    async function loadEntry(id, locale, path, draft) {
+        const { entries } = options.stores();
+        for (const schema of mounted) {
+            const record = await entries.get(schema.name, id);
+            if (!record)
+                continue;
+            if (!draft && record.status !== "published")
+                return null;
+            const fields = await resolveFields(localizeFields(record.fields, record.i18n, locale, locales), schema.fields, {
+                collections: options.collections,
+                fetch: fetcher(draft),
+            });
+            return {
+                kind: "entry",
+                collection: schema.name,
+                entry: { ...record, fields },
+                path,
+                paths: await entries.pathsOf(schema.name, id),
+            };
+        }
+        return null;
+    }
+    const localeOf = (o) => o?.locale ?? locales.default;
+    /** Localized fields and the locale's path for entries of one collection;
+     *  `all` is the whole collection (drafts included: a draft ancestor
+     *  still contributes its segment). */
+    function entryItems(schema, wanted, all, locale) {
+        const index = new Map(all.map((e) => [e.id, e]));
+        const byId = (x) => index.get(x);
+        return wanted.map((record) => ({
+            entry: { ...record, fields: localizeFields(record.fields, record.i18n, locale, locales) },
+            path: entryPathRows([record], byId, schema, locales).find((r) => r.locale === locale)?.path ?? null,
+        }));
+    }
+    const publicEntry = (e, locale) => e.status === "published" && localesOf(e, locales).includes(locale);
+    async function getEntries(collection, o = {}) {
+        const schema = schemaOf(options.collections, collection);
+        const locale = localeOf(o);
+        const { entries } = options.stores();
+        const all = await entries.list(collection, { order: o.order });
+        const wanted = all.filter((e) => publicEntry(e, locale) && (o.parent === undefined || e.parentId === o.parent));
+        return entryItems(schema, wanted, all, locale);
+    }
+    const api = {
+        async getPagesTree(o) {
+            const locale = localeOf(o);
+            const all = await options.stores().pages.listPages();
+            const shown = all.filter((n) => visible(n, false) && localesOf(n, locales).includes(locale));
+            const toItem = (node) => ({
+                id: node.record.id,
+                title: titleFor(node.record, locale, locales),
+                path: node.path,
+                hasPage: hasPage(node.record, false),
+                children: node.children.map(toItem),
+            });
+            return buildPageTree(shown, locale, pathOpts).map(toItem);
+        },
+        async getPage(pathOrId, o) {
+            const locale = localeOf(o);
+            const path = pathOrId.startsWith("/") ? pathOrId : (await options.stores().pages.pathsOf(pathOrId))[locale];
+            if (!path)
+                return null;
+            const hit = await site.resolve(locale, path);
+            return hit?.kind === "page" ? hit : null;
+        },
+        getEntries,
+        async getEntry(collection, idOrPath, o) {
+            schemaOf(options.collections, collection); // an unknown collection is a wiring error on every branch
+            const locale = localeOf(o);
+            if (idOrPath.startsWith("/")) {
+                const hit = await site.resolve(locale, idOrPath);
+                return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path } : null;
+            }
+            const items = await getEntries(collection, { locale });
+            const byId = items.find((i) => i.entry.id === idOrPath);
+            if (byId)
+                return byId;
+            // A bare slug names a ROOT entry only (sibling-scoped slugs, spec §4):
+            // match the localized slug directly (paths.ts owns slug derivation),
+            // regardless of whether the collection even has a `path`.
+            return items.find((i) => i.entry.parentId === null && entrySegment(i.entry, locale, locales) === idOrPath) ?? null;
+        },
+        async getEntriesTree(collection, o) {
+            const items = await getEntries(collection, { locale: localeOf(o) });
+            const build = (parentId) => items.filter((i) => i.entry.parentId === parentId).map((i) => ({ ...i, children: build(i.entry.id) }));
+            return build(null);
+        },
+    };
+    const site = {
+        locales,
+        homePageSlug,
+        locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
+        load(target, locale, path, opts = {}) {
+            const draft = opts.draft ?? false;
+            return target.kind === "page" ? loadPage(target.id, locale, path, draft) : loadEntry(target.id, locale, path, draft);
+        },
+        async resolve(locale, path, opts) {
+            const target = await site.locate(locale, path);
+            return target ? site.load(target, locale, path, opts) : null;
+        },
+        ...api,
+    };
+    return site;
+}

package/dist/sql-space.d.ts

@@ -1,6 +1,6 @@
 export declare const DEFAULT_SPACE = "'00000000-0000-0000-0000-000000000000'";
 export declare const SPACE_COL = "\"space_id\" uuid not null default '00000000-0000-0000-0000-000000000000'";
-export declare const CONTENT_TABLES: readonly ["pages", "page_versions", "saved_sections", "global_sections", "entries", "refs"];
+export declare const CONTENT_TABLES: readonly ["pages", "page_versions", "saved_sections", "global_sections", "entries", "refs", "paths"];
 export type ContentTable = (typeof CONTENT_TABLES)[number];
 export declare function currentSpaceSQL(): string;
 export declare function spaceLayerSQL(): string;

package/dist/sql-space.js

@@ -11,6 +11,7 @@ export const CONTENT_TABLES = [
     "global_sections",
     "entries",
     "refs",
+    "paths",
 ];
 export function currentSpaceSQL() {
     return `
@@ -35,6 +36,7 @@ const PUBLISHED_READ = {
     saved_sections: null,
     refs: null,
     editors: null,
+    paths: `(("kind" = 'page' and exists (select 1 from "pages" p where p."id" = "paths"."target_id" and p."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entries" e where e."id" = "paths"."target_id" and e."status" = 'published')))`,
 };
 /** Tables whose existing indexes do not lead with space_id. */
 const NEEDS_SPACE_INDEX = ["page_versions", "saved_sections", "global_sections", "refs"];

package/dist/sql.d.ts

@@ -1,3 +1,3 @@
-import type { CollectionSchema } from "./collections.ts";
+import { type CollectionSchema } from "./collections.ts";
 export declare function collectionSQL(collection: CollectionSchema<any>): string;
 export declare function coreTablesSQL(): string;

package/dist/sql.js

@@ -4,15 +4,18 @@
 // disposable guardrails — a published-only read view, created with
 // security_invoker so it runs under the caller's own RLS policies
 // rather than the view owner's privileges (PostgREST-native reads,
-// SQL-queryable eject story) — and partial expression indexes (slug
-// uniqueness, declared orderBy fields). Views project the default
-// locale; the `i18n` overlay is the resolver/API's business.
+// SQL-queryable eject story) — and a partial expression index for a
+// declared order field, on the jsonb VALUE (slug uniqueness is a core
+// index, scoped to siblings, not per collection). Views project the
+// default locale; the `i18n` overlay is the resolver/API's business.
+import { BUILT_IN_ORDER_FIELDS } from "./collections.js";
 import { currentSpaceSQL, 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
-// immutable — orderBy indexes stay on the text value; ISO dates sort
-// correctly as text).
+// immutable — the order field's index stays on the raw jsonb
+// expression: jsonb ordering compares numbers numerically and strings,
+// ISO dates included, alphabetically, matching the memory comparator).
 function fieldExpr(key, d) {
     switch (d.type) {
         case "text":
@@ -44,11 +47,15 @@ export function collectionSQL(collection) {
             `where "collection" = '${name}' and "status" = 'published';`,
         ].join("\n"),
     ];
-    // slug uniqueness is the generic core index (space_id, collection, slug);
-    // only declared orderBy fields need per-collection expression indexes
-    for (const key of Object.keys(collection.admin?.orderBy ?? {})) {
-        statements.push(`create index if not exists ${q(`entries_${name}_${snake(key)}_idx`)}\n` +
-            `  on "entries" (("fields"->>'${key}')) where "collection" = '${name}';`);
+    // slug uniqueness is the generic core index, scoped to siblings
+    // (space_id, collection, parent_id, slug); only a declared order field
+    // needs a per-collection expression index — the built-in timestamps are
+    // real columns already. The expression is the jsonb value (`->`), the
+    // same one the adapter orders by, so the index actually serves the sort.
+    const order = collection.order;
+    if (order !== undefined && order !== "manual" && !BUILT_IN_ORDER_FIELDS.includes(order.by)) {
+        statements.push(`create index if not exists ${q(`entries_${name}_${snake(order.by)}_idx`)}\n` +
+            `  on "entries" (("fields"->'${order.by}')) where "collection" = '${name}';`);
     }
     return statements.join("\n\n");
 }
@@ -63,18 +70,37 @@ export function coreTablesSQL() {
 create table if not exists "pages" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
+  "parent_id" uuid references "pages" ("id") on delete restrict,
   "slug" text not null,
-  "template" text not null,
+  "title" text not null,
+  "i18n" jsonb,
+  "template" text,
   "status" text not null default 'draft',
   "sort" numeric,
   "locales" text[],
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "created_at" timestamptz not null default now(),
-  "updated_at" timestamptz not null default now(),
-  unique ("space_id", "slug")
+  "updated_at" timestamptz not null default now()
 );
 
+-- The tree is the URL (spec 2026-09-05 §1): a node stores its own segment
+-- and its parent. Siblings are unique per segment; NULLS NOT DISTINCT so
+-- two root nodes cannot share one either. template null = folder.
+create unique index if not exists "pages_sibling_slug_key"
+  on "pages" ("space_id", "parent_id", "slug") nulls not distinct;
+
+create index if not exists "pages_parent_idx"
+  on "pages" ("space_id", "parent_id", "sort");
+
+-- 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 $$
+  update "pages" pg set "sort" = u.ord
+  from unnest(p_ids) with ordinality as u(id, ord)
+  where pg."id" = u.id
+    and pg."space_id" = "smoodly_current_space"();
+$$;
+
 create table if not exists "page_versions" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
@@ -104,6 +130,7 @@ create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "collection" text not null,
+  "parent_id" uuid references "entries" ("id") on delete restrict,
   "fields" jsonb not null default '{}'::jsonb,
   "i18n" jsonb,
   "status" text not null default 'draft',
@@ -113,8 +140,22 @@ create table if not exists "entries" (
   "updated_at" timestamptz not null default now()
 );
 
-create unique index if not exists "entries_slug_key"
-  on "entries" ("space_id", "collection", ("fields"->>'slug'));
+-- Entry slugs are unique among SIBLINGS, like pages: one rule for every
+-- node in the tree, and the URL is the tree. NULLS NOT DISTINCT so two
+-- ROOT entries (parent_id null) cannot share a slug either. The partial
+-- predicate keeps absent, null, empty or non-string slugs out of the
+-- index entirely: with NULLS NOT DISTINCT a null slug would otherwise
+-- collide with the next null slug, and a collection with no slug field
+-- at all could hold only one entry per parent. jsonb_typeof(...) =
+-- 'string' is required because ->> renders ANY JSON scalar as text —
+-- a number, boolean or null slug would otherwise print as non-empty
+-- text and claim the index; only a non-empty string slug claims a URL,
+-- absent, null, empty or non-string slugs never conflict — the same
+-- rule as slugOf in paths.ts. A flat collection (every entry a root)
+-- therefore behaves exactly as per-collection uniqueness did.
+create unique index if not exists "entries_sibling_slug_key"
+  on "entries" ("space_id", "collection", "parent_id", ("fields"->>'slug')) nulls not distinct
+  where (jsonb_typeof("fields"->'slug') = 'string' and "fields"->>'slug' <> '');
 
 create index if not exists "entries_collection_status_idx"
   on "entries" ("space_id", "collection", "status");
@@ -122,6 +163,9 @@ create index if not exists "entries_collection_status_idx"
 create index if not exists "entries_collection_sort_idx"
   on "entries" ("space_id", "collection", "sort");
 
+create index if not exists "entries_parent_idx"
+  on "entries" ("space_id", "collection", "parent_id");
+
 -- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
 -- statement. Deliberately does not touch updated_at — a drag must not
 -- make the whole collection look freshly edited. Scoped to the current
@@ -147,6 +191,38 @@ create table if not exists "refs" (
   primary key ("source_kind", "source_id", "source_field", "target_id")
 );
 
+-- The URL index (spec 2026-09-05 §4): the refs counterpart for paths.
+-- Derived — the stores rewrite a target's rows on every create, rename,
+-- move and delete — so one primary-key hit resolves any URL in any locale
+-- 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.
+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,
+  primary key ("space_id", "locale", "path")
+);
+
+create index if not exists "paths_target_idx"
+  on "paths" ("space_id", "kind", "target_id");
+
+-- Replace the targets' rows with the given rows in ONE call: a SQL
+-- 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 $$
+  delete from "paths" p
+  using jsonb_to_recordset(p_targets) as t(kind text, id uuid)
+  where p."kind" = t.kind and p."target_id" = t.id
+    and p."space_id" = "smoodly_current_space"();
+  insert into "paths" ("locale", "path", "kind", "target_id")
+  select r.locale, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid);
+$$;
+
 -- RLS on every core table. The service role bypasses it (self-host
 -- adapters untouched). The policy set that follows (space layer) admits
 -- a key to its own space: everything for a write key, published rows for
@@ -160,6 +236,7 @@ alter table "saved_sections" enable row level security;
 alter table "global_sections" enable row level security;
 alter table "entries" enable row level security;
 alter table "refs" enable row level security;
+alter table "paths" enable row level security;
 `.trim(),
         spaceLayerSQL(),
     ].join("\n\n");