smoodly 0.0.6 → 0.0.8

package/dist/site.d.ts

@@ -3,6 +3,7 @@ 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 SharedSchema } from "./shared.ts";
 import type { PageRecord, PageStore } from "./store.ts";
 export type SiteOptions = {
     stores: () => {
@@ -11,6 +12,7 @@ export type SiteOptions = {
     };
     collections: CollectionSchema<any>[];
     sections: SectionLike[];
+    shared?: SharedSchema[];
     locales: LocaleSet;
     homePageSlug?: string;
 };
@@ -23,13 +25,17 @@ export type SitePage = {
     path: string;
     ancestors: PageLink[];
     children: PageLink[];
-    /** locale → path, for metadata alternates. */
+    /** locale → path, for metadata alternates: the locales the page is
+     *  PUBLISHED in, since that is what may be advertised — draft mode
+     *  carries every locale the page exists in. */
     paths: Record<string, string>;
 };
 export type SiteEntry = {
     kind: "entry";
     collection: string;
-    /** `fields` are localized for the requested locale with refs resolved. */
+    /** `fields` are the locale's MERGED fields — shared + localized + slug —
+     *  with refs resolved: the published snapshot on the public path, the
+     *  live row in draft mode. */
     entry: EntryRecord;
     path: string;
     paths: Record<string, string>;
@@ -78,6 +84,14 @@ export interface SmoodlySite {
     getEntriesTree(collection: string, options?: {
         locale?: string;
     }): Promise<EntryTreeItem[]>;
+    /** A shared item's content in a locale (spec 2026-09-07 §4): an object
+     *  item's merged fields, or a visual item's section props (fields plus
+     *  `styles`), refs hydrated; null when the item has no row there or is
+     *  unpublished (outside draft mode). */
+    getShared<V>(item: SharedSchema<V>, options?: {
+        locale?: string;
+        draft?: boolean;
+    }): Promise<V | null>;
 }
 /** 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. */

package/dist/site.js

@@ -1,7 +1,7 @@
-import { schemaOf } from "./entry-store.js";
-import { localizeFields, titleFor } from "./localize.js";
-import { buildPageTree, chainOf, entryPathRows, entrySegment, localesOf, pagePath, } from "./paths.js";
+import { entryFieldsIn, schemaOf } from "./entry-store.js";
+import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
 import { resolveFields, resolveTree } from "./resolve.js";
+import { STYLES_KEY } from "./shared.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) {
@@ -20,42 +20,64 @@ export function createSmoodlySite(options) {
     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);
+    /** The resolver's fetcher, bound to a locale: the merged fields of that
+     *  locale — published ones (a versioned collection's snapshot) on the
+     *  public path, the live rows in draft mode. */
+    const fetcher = (draft, locale) => (collection, ids) => options.stores().entries.getMany(collection, ids, locale, draft ? undefined : { status: "published" });
+    /** Visible to the public in a locale: present there, and a folder or a
+     *  published page. Draft mode sees every present node. Presence is the
+     *  locale row — nothing falls back (spec 2026-09-06 §3). */
+    const visible = (node, locale, draft) => {
+        const row = node.locales[locale];
+        return row !== undefined && (draft || node.template === null || row.status === "published");
+    };
+    const hasPage = (node, locale, draft) => {
+        const row = node.locales[locale];
+        return node.template !== null && row !== undefined && (draft || row.status === "published");
+    };
+    /** Only ever called for a node PRESENT in the locale (visible() or an ancestor of one). */
     const link = (node, byId, locale, draft) => ({
-        title: titleFor(node, locale, locales),
+        title: node.locales[locale].title,
         path: pagePath(node, byId, locale, pathOpts),
-        hasPage: hasPage(node, draft),
+        hasPage: hasPage(node, locale, 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;
+        const row = record.locales[locale];
+        if (!row)
+            return null;
+        const raw = draft ? await pages.getDraftTree(id, locale) : row.status === "published" ? await pages.getPublishedTree(id, locale) : null;
         if (!raw)
             return null;
-        const tree = await resolveTree(raw, { sections: options.sections, collections: options.collections, fetch: fetcher(draft) });
+        const tree = await resolveTree(raw, {
+            sections: options.sections,
+            collections: options.collections,
+            shared: options.shared,
+            fetch: fetcher(draft, locale),
+        });
         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))
+            .filter((n) => n.parentId === id && visible(n, locale, draft))
             .map((n) => link(n, byId, locale, draft));
+        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
+        const paths = Object.fromEntries(Object.entries(await pages.pathsOf(id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
         return {
             kind: "page",
             record,
             template: record.template,
             tree,
-            title: titleFor(record, locale, locales),
+            title: row.title,
             path,
             ancestors,
             children,
-            paths: await pages.pathsOf(id),
+            paths,
         };
     }
     async function loadEntry(id, locale, path, draft) {
@@ -64,53 +86,63 @@ export function createSmoodlySite(options) {
             const record = await entries.get(schema.name, id);
             if (!record)
                 continue;
-            if (!draft && record.status !== "published")
+            // No row, or a draft row outside draft mode, is a 404 for THIS locale.
+            const row = record.locales[locale];
+            if (!row)
                 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),
-            };
+            if (!draft && row.status !== "published")
+                return null;
+            const raw = draft
+                ? entryFieldsIn(record, locale)
+                : (await entries.getMany(schema.name, [id], locale, { status: "published" }))[id];
+            if (!raw)
+                return null;
+            const fields = await resolveFields(raw, schema.fields, { collections: options.collections, fetch: fetcher(draft, locale) });
+            // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
+            const paths = Object.fromEntries(Object.entries(await entries.pathsOf(schema.name, id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
+            return { kind: "entry", collection: schema.name, entry: { ...record, fields }, path, paths };
         }
         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) {
+    /** One locale's published fields and path for entries of one collection;
+     *  `all` is the whole collection (a draft ancestor still contributes
+     *  its segment). `fieldsById` is the published read for the locale. */
+    function entryItems(schema, wanted, all, locale, fieldsById) {
         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) },
+        return wanted
+            .filter((record) => fieldsById[record.id] !== undefined)
+            .map((record) => ({
+            entry: { ...record, fields: fieldsById[record.id] },
             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);
+    /** Public in a locale: its row exists there and is published. */
+    const publicEntry = (e, locale) => e.locales[locale]?.status === "published";
     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 published = await entries.getMany(collection, wanted.map((e) => e.id), locale, { status: "published" });
+        return entryItems(schema, wanted, all, locale, published);
     }
     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 shown = all.filter((n) => visible(n, locale, false));
+            const index = new Map(shown.map((n) => [n.id, n]));
             const toItem = (node) => ({
                 id: node.record.id,
-                title: titleFor(node.record, locale, locales),
-                path: node.path,
-                hasPage: hasPage(node.record, false),
+                title: node.record.locales[locale].title,
+                // Every node the walk reaches is present with a present chain, so
+                // buildPageTree's nullable path is never null here; pagePath is
+                // the same derivation and keeps the type honest.
+                path: node.path ?? pagePath(node.record, (x) => index.get(x), locale, pathOpts),
+                hasPage: hasPage(node.record, locale, false),
                 children: node.children.map(toItem),
             });
             return buildPageTree(shown, locale, pathOpts).map(toItem);
@@ -138,13 +170,34 @@ export function createSmoodlySite(options) {
             // 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;
+            return items.find((i) => i.entry.parentId === null && entrySegment(i.entry, locale) === 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);
         },
+        async getShared(item, o) {
+            const locale = localeOf(o);
+            const draft = o?.draft ?? false;
+            const { entries } = options.stores();
+            const [record] = await entries.list(item.name);
+            if (!record)
+                return null;
+            const row = record.locales[locale];
+            if (!row || (!draft && row.status !== "published"))
+                return null;
+            const raw = draft
+                ? entryFieldsIn(record, locale)
+                : (await entries.getMany(item.name, [record.id], locale, { status: "published" }))[record.id];
+            if (!raw)
+                return null;
+            const fields = await resolveFields(raw, item.fields, { collections: options.collections, fetch: fetcher(draft, locale) });
+            if (!item.section)
+                return fields;
+            const { [STYLES_KEY]: styles, ...rest } = fields;
+            return { ...rest, styles: styles !== null && typeof styles === "object" ? styles : {} };
+        },
     };
     const site = {
         locales,

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", "paths"];
+export declare const CONTENT_TABLES: readonly ["pages", "page_locales", "page_versions", "entries", "entry_locales", "entry_versions", "refs", "paths"];
 export type ContentTable = (typeof CONTENT_TABLES)[number];
 export declare function currentSpaceSQL(): string;
 export declare function spaceLayerSQL(): string;

package/dist/sql-space.js

@@ -6,10 +6,11 @@ export const DEFAULT_SPACE = `'00000000-0000-0000-0000-000000000000'`;
 export const SPACE_COL = `"space_id" uuid not null default ${DEFAULT_SPACE}`;
 export const CONTENT_TABLES = [
     "pages",
+    "page_locales",
     "page_versions",
-    "saved_sections",
-    "global_sections",
     "entries",
+    "entry_locales",
+    "entry_versions",
     "refs",
     "paths",
 ];
@@ -24,22 +25,24 @@ language sql stable as $$
 $$;`.trim();
 }
 /** Which rows a read key (or the anon key, which has no claim) may see.
- *  null = write keys only — refs and the section library are editor
- *  tooling; editors is admission data; nothing a browser needs. The
- *  empty string means "read policy, no extra predicate" (global_sections
- *  is fully readable once it's in-space) — distinct from null. */
+ *  null = write keys only — refs is editor tooling; editors is admission
+ *  data; nothing a browser needs. Shared content (spec 2026-09-07) rides
+ *  the three entry predicates: it is stored as entries. */
 const PUBLISHED_READ = {
-    pages: `"status" = 'published'`,
-    entries: `"status" = 'published'`,
-    page_versions: `exists (select 1 from "pages" p where p."published_version_id" = "page_versions"."id")`,
-    global_sections: ``,
-    saved_sections: null,
+    pages: `exists (select 1 from "page_locales" l where l."page_id" = "pages"."id" and l."status" = 'published')`,
+    page_locales: `"status" = 'published'`,
+    page_versions: `exists (select 1 from "page_locales" l where l."published_version_id" = "page_versions"."id")`,
+    entries: `exists (select 1 from "entry_locales" l where l."entry_id" = "entries"."id" and l."status" = 'published')`,
+    entry_locales: `"status" = 'published'`,
+    entry_versions: `exists (select 1 from "entry_locales" l where l."published_version_id" = "entry_versions"."id")`,
     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')))`,
+    paths: `(("kind" = 'page' and exists (select 1 from "page_locales" l where l."page_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entry_locales" l where l."entry_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published')))`,
 };
 /** Tables whose existing indexes do not lead with space_id. */
-const NEEDS_SPACE_INDEX = ["page_versions", "saved_sections", "global_sections", "refs"];
+const NEEDS_SPACE_INDEX = [
+    "page_locales", "page_versions", "entry_locales", "entry_versions", "refs",
+];
 export function spaceLayerSQL() {
     const statements = [];
     statements.push(`

package/dist/sql.js

@@ -5,9 +5,11 @@
 // 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 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.
+// declared order field, on the jsonb VALUE (sibling slug uniqueness
+// is the `paths` primary key plus the stores' per-locale pre-check,
+// not an index). A view joins the locale rows, one row per published
+// 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";
 const snake = (s) => s.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
@@ -16,42 +18,50 @@ const q = (s) => `"${s}"`;
 // 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) {
+function fieldExpr(key, d, source) {
     switch (d.type) {
         case "text":
         case "link":
         case "slug":
         case "select":
         case "ref": // stored as the target entry's id string
-            return `"fields"->>'${key}'`;
+            return `${source}->>'${key}'`;
         case "number":
-            return `("fields"->>'${key}')::numeric`;
+            return `(${source}->>'${key}')::numeric`;
         case "date":
-            return `("fields"->>'${key}')::timestamptz`;
+            return `(${source}->>'${key}')::timestamptz`;
         default:
-            return `"fields"->'${key}'`; // image, video, file, object, richtext, dataAttributes, refList
+            return `${source}->'${key}'`; // image, video, file, object, richtext, dataAttributes, refList
     }
 }
 export function collectionSQL(collection) {
     const name = collection.name;
-    const columns = ['"id"', '"sort"', '"locales"', '"created_at"', '"updated_at"'];
+    const versioned = collection.versions === true;
+    // Where a field's value lives: a versioned collection's view reads the
+    // published snapshot (merged at publish time); otherwise shared fields
+    // come from the node and localized ones from the locale row.
+    const sourceOf = (d) => (versioned ? 'v."fields"' : d.localized === true ? 'l."fields"' : 'e."fields"');
+    const columns = ['e."id"', 'l."locale"', 'l."slug"', 'e."sort"', 'e."created_at"', 'l."updated_at"'];
     for (const [key, d] of Object.entries(collection.fields)) {
-        columns.push(`${fieldExpr(key, d)} as ${q(snake(key))}`);
+        if (key === "slug")
+            continue; // the segment is the row's column, never a field
+        columns.push(`${fieldExpr(key, d, sourceOf(d))} as ${q(snake(key))}`);
     }
     const statements = [
         [
             `create or replace view ${q(name)} with (security_invoker = true) as`,
             `select`,
             columns.map((c) => "  " + c).join(",\n"),
-            `from "entries"`,
-            `where "collection" = '${name}' and "status" = 'published';`,
+            `from "entries" e`,
+            `join "entry_locales" l on l."entry_id" = e."id"`,
+            ...(versioned ? [`join "entry_versions" v on v."id" = l."published_version_id"`] : []),
+            `where e."collection" = '${name}' and l."status" = 'published';`,
         ].join("\n"),
     ];
-    // 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.
+    // Only a declared order field needs a per-collection expression index —
+    // on the node's shared fields (an order field can be neither localized
+    // nor `slug`, which collection() refuses), the jsonb value (`->`) the
+    // adapter orders by, so the index 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` +
@@ -71,28 +81,34 @@ 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,
-  "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()
 );
 
--- 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;
-
+-- The tree is the URL (spec 2026-09-05 §1): a node stores its parent and
+-- its position; template null = folder. Everything a locale owns — the
+-- node's own segment, title, publish state and version pointers — lives
+-- in page_locales, one row per locale the page exists in (spec 2026-09-06
+-- §2). There is no sibling-slug index: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same operation.
 create index if not exists "pages_parent_idx"
   on "pages" ("space_id", "parent_id", "sort");
 
+create table if not exists "page_locales" (
+  ${SPACE_COL},
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text not null,
+  "title" text not null,
+  "status" text not null default 'draft',
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+
 -- 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
@@ -101,30 +117,20 @@ create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void la
     and pg."space_id" = "smoodly_current_space"();
 $$;
 
+-- A version belongs to ONE locale of one page: each locale has its own
+-- draft, its own publish and its own history.
 create table if not exists "page_versions" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
   "tree" jsonb not null,
   "created_by" text,
   "created_at" timestamptz not null default now()
 );
 
-create table if not exists "saved_sections" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "title" text not null,
-  "fragment" jsonb not null,
-  "created_at" timestamptz not null default now()
-);
-
-create table if not exists "global_sections" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "type" text not null,
-  "content" jsonb not null,
-  "updated_at" timestamptz not null default now()
-);
+create index if not exists "page_versions_page_locale_idx"
+  on "page_versions" ("page_id", "locale", "created_at");
 
 create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
@@ -132,40 +138,58 @@ create table if not exists "entries" (
   "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',
   "sort" numeric,
-  "locales" text[],
   "created_at" timestamptz not null default now(),
   "updated_at" timestamptz not null default now()
 );
 
--- 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");
-
+-- The node holds identity, tree position and the SHARED fields — every
+-- field without .localized() (spec 2026-09-06 §7): a Person's photo is
+-- the same in every language. Everything a locale owns — its segment,
+-- publish state, the .localized() fields and the version pointers —
+-- lives in entry_locales, one row per locale the entry exists in. There
+-- is no sibling-slug index any more: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same
+-- operation, and both adapters pre-check siblings per locale in code.
 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");
 
+create table if not exists "entry_locales" (
+  ${SPACE_COL},
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text,
+  "status" text not null default 'draft',
+  "fields" jsonb not null default '{}'::jsonb,
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+
+create index if not exists "entry_locales_status_idx"
+  on "entry_locales" ("space_id", "locale", "status");
+
+-- A version belongs to ONE locale of one entry and stores the MERGED
+-- fields (shared + localized + slug) as they were at that save, so
+-- restoring an old Finnish version restores the shared fields too.
+-- Rows exist only for collections registered with \`versions: true\`.
+create table if not exists "entry_versions" (
+  "id" uuid primary key default gen_random_uuid(),
+  ${SPACE_COL},
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "fields" jsonb not null,
+  "created_by" text,
+  "created_at" timestamptz not null default now()
+);
+
+create index if not exists "entry_versions_entry_locale_idx"
+  on "entry_versions" ("entry_id", "locale", "created_at");
+
 -- 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
@@ -231,10 +255,11 @@ $$;
 -- (collectionSQL) run with security_invoker = true, so they are subject
 -- to this same smoodly_read policy rather than their owner's privileges.
 alter table "pages" enable row level security;
+alter table "page_locales" enable row level security;
 alter table "page_versions" enable row level security;
-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 "entry_locales" enable row level security;
+alter table "entry_versions" enable row level security;
 alter table "refs" enable row level security;
 alter table "paths" enable row level security;
 `.trim(),