smoodly 0.0.6 → 0.0.7

package/dist/paths.d.ts

@@ -5,8 +5,21 @@ export type LocaleSet = {
     default: string;
     supported: string[];
 };
+/** ONE text for both stores: a locale outside the config set. */
+export declare const unsupportedLocale: (locale: string) => Error;
+export declare function assertSupportedLocale(locale: string, set: LocaleSet): void;
 /** A per-locale segment map: a string applies to every supported locale; an object is copied as declared. */
 export declare function perLocaleSegments(value: string | Record<string, string>, supported: string[]): Record<string, string>;
+/** The segments a FIXED PAGE registration claims, per locale. A
+ *  registration declares its slugs in code, so a locale its map omits
+ *  means "the default locale's segment", not "absent" — the
+ *  page_locales presence rule is about records, not registrations
+ *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
+ *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
+ *  (localize.ts) all fill through here, or a collision passes boot and
+ *  only surfaces at materialization. Collection mounts are NOT filled:
+ *  a per-locale path claims exactly the locales it names. */
+export declare function fixedPageSegments(slug: string | Record<string, string>, locales: LocaleSet): Record<string, string>;
 export type PathTarget = {
     kind: "page" | "entry";
     id: string;
@@ -17,18 +30,10 @@ export type PathRow = PathTarget & {
 };
 export declare const joinPath: (segments: string[]) => string;
 export declare const splitPath: (path: string) => string[];
-type SlugI18n = Record<string, {
-    slug?: string;
-}> | null | undefined;
-/** The locale's own segment, or the default locale's (per-field fallback). */
-export declare function segmentFor(node: {
-    slug: string;
-    i18n?: SlugI18n;
-}, locale: string, set: LocaleSet): string;
-/** null = every supported locale; otherwise the intersection. */
-export declare function localesOf(node: {
-    locales?: string[] | null;
-}, set: LocaleSet): string[];
+/** The node's segment in one locale. An absent locale is an error, never
+ *  a fallback: the stores' parent rule guarantees a present node has a
+ *  present ancestor chain, so a throw here is a broken invariant. */
+export declare function segmentFor(node: PageLike, locale: string): string;
 export declare function chainOf<T extends {
     id: string;
     parentId: string | null;
@@ -37,44 +42,58 @@ export declare function assertDepth(depth: number, max: number, what: string): v
 export type PageLike = {
     id: string;
     parentId: string | null;
-    slug: string;
-    i18n: Record<string, {
-        slug?: string;
-        title?: string;
-    }> | null;
-    locales: string[] | null;
+    /** The locales the node exists in, each with the node's OWN segment there. Presence IS the key (spec 2026-09-06 §3). */
+    locales: Record<string, {
+        slug: string;
+    }>;
 };
 export type PagePathOptions = {
     locales: LocaleSet;
     homePageSlug: string;
 };
+/** Home is judged by identity: the root node whose DEFAULT-locale slug is
+ *  homePageSlug serves "/" in every locale it exists in. */
+export declare const isHomeNode: (node: PageLike, opts: PagePathOptions) => boolean;
 /** The node's path in one locale: `/` for the home node, else the
- *  localized ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export declare function pagePath(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string;
+/** The same path, or null when the node or an ancestor is absent from the
+ *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+export declare function pagePathIn(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string | null;
+/** One row per locale the target EXISTS in. */
 export declare function pagePathRows(targets: PageLike[], byId: (id: string) => PageLike | undefined, opts: PagePathOptions): PathRow[];
 export type EntryLike = {
     id: string;
     parentId: string | null;
-    fields: Record<string, unknown>;
-    i18n: Record<string, Record<string, unknown>> | null;
-    locales: string[] | null;
+    /** The locales the entry exists in, each with its OWN segment there (null =
+     *  the entry claims no URL in that locale). Presence IS the key (spec
+     *  2026-09-06 §7). */
+    locales: Record<string, {
+        slug: string | null;
+    }>;
 };
 export declare function collectionSegment(path: string | Record<string, string> | undefined, locale: string, set: LocaleSet): string | null;
 /** The "claims a URL" predicate (§1): a slug is only a real segment when
  * it is a non-empty string — absent, null, or `""` all mean "no URL".
- * The sibling index predicate in sql.ts (`entries_sibling_slug_key`)
- * mirrors this rule exactly, so Postgres and memory agree on which
+ * There is no sibling-slug index: sibling uniqueness is the primary key
+ * of `paths` plus the pre-check each store makes per locale before it
+ * writes (spec 2026-09-06 §12), so Postgres and memory agree on which
  * entries can collide. */
 export declare const slugOf: (fields: Record<string, unknown>) => string | null;
-export declare function entrySegment(entry: EntryLike, locale: string, set: LocaleSet): string | null;
+/** The entry's segment in one locale: its row's slug. An absent locale
+ *  or a slug-less row is null — no URL there, never a fallback. */
+export declare function entrySegment(entry: EntryLike, locale: string): string | null;
+/** One row per locale the target EXISTS in, where the whole chain has a
+ *  segment in that locale. The stores' parent rule guarantees an ancestor
+ *  is present wherever a descendant is; an ancestor without a slug there
+ *  simply yields no URL for the subtree in that locale. */
 export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
     path?: string | Record<string, string>;
 }, set: LocaleSet): PathRow[];
 export type PageTreeNode<T extends PageLike> = {
     record: T;
-    path: string;
+    path: string | null;
     children: PageTreeNode<T>[];
 };
 export declare function buildPageTree<T extends PageLike>(records: T[], locale: string, opts: PagePathOptions): PageTreeNode<T>[];
-export {};

package/dist/paths.js

@@ -1,6 +1,7 @@
-// The one place a URL is derived (spec 2026-09-05 §1, §4). Pure and
-// framework-free: both store adapters and the tree query call these, so
-// the `paths` index and every derived `path` value agree by construction.
+// The one place a URL is derived (spec 2026-09-05 §1, §4; spec
+// 2026-09-06 §3, §7). Pure and framework-free: both store adapters and
+// the tree query call these, so the `paths` index and every derived
+// `path` value agree by construction.
 export const SEGMENT_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 export const isSegment = (s) => SEGMENT_RE.test(s);
 export function assertSegment(s, what) {
@@ -8,24 +9,39 @@ export function assertSegment(s, what) {
         throw new Error(`smoodly: ${what} "${s}" is not a valid slug — use lowercase letters, digits and single hyphens.`);
     }
 }
+/** ONE text for both stores: a locale outside the config set. */
+export const unsupportedLocale = (locale) => new Error(`smoodly: "${locale}" is not a supported locale.`);
+export function assertSupportedLocale(locale, set) {
+    if (!set.supported.includes(locale))
+        throw unsupportedLocale(locale);
+}
 /** A per-locale segment map: a string applies to every supported locale; an object is copied as declared. */
 export function perLocaleSegments(value, supported) {
     return typeof value === "string" ? Object.fromEntries(supported.map((l) => [l, value])) : { ...value };
 }
+/** The segments a FIXED PAGE registration claims, per locale. A
+ *  registration declares its slugs in code, so a locale its map omits
+ *  means "the default locale's segment", not "absent" — the
+ *  page_locales presence rule is about records, not registrations
+ *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
+ *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
+ *  (localize.ts) all fill through here, or a collision passes boot and
+ *  only surfaces at materialization. Collection mounts are NOT filled:
+ *  a per-locale path claims exactly the locales it names. */
+export function fixedPageSegments(slug, locales) {
+    const raw = perLocaleSegments(slug, locales.supported);
+    return Object.fromEntries(locales.supported.map((l) => [l, raw[l] || raw[locales.default]]));
+}
 export const joinPath = (segments) => (segments.length === 0 ? "/" : "/" + segments.join("/"));
 export const splitPath = (path) => path.split("/").filter((s) => s.length > 0);
-/** The locale's own segment, or the default locale's (per-field fallback). */
-export function segmentFor(node, locale, set) {
-    if (locale === set.default)
-        return node.slug;
-    const own = node.i18n?.[locale]?.slug;
-    return typeof own === "string" && own.length > 0 ? own : node.slug;
-}
-/** null = every supported locale; otherwise the intersection. */
-export function localesOf(node, set) {
-    if (!node.locales)
-        return [...set.supported];
-    return set.supported.filter((l) => node.locales.includes(l));
+/** The node's segment in one locale. An absent locale is an error, never
+ *  a fallback: the stores' parent rule guarantees a present node has a
+ *  present ancestor chain, so a throw here is a broken invariant. */
+export function segmentFor(node, locale) {
+    const own = node.locales[locale];
+    if (!own)
+        throw new Error(`smoodly: page "${node.id}" does not exist in locale "${locale}".`);
+    return own.slug;
 }
 export function chainOf(node, byId) {
     const chain = [node];
@@ -43,19 +59,30 @@ export function assertDepth(depth, max, what) {
     if (depth > max)
         throw new Error(`smoodly: ${what} would exceed the tree depth (${max}).`);
 }
-const isHome = (node, homePageSlug) => node.parentId === null && node.slug === homePageSlug;
+/** Home is judged by identity: the root node whose DEFAULT-locale slug is
+ *  homePageSlug serves "/" in every locale it exists in. */
+export const isHomeNode = (node, opts) => node.parentId === null && node.locales[opts.locales.default]?.slug === opts.homePageSlug;
 /** The node's path in one locale: `/` for the home node, else the
- *  localized ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export function pagePath(node, byId, locale, opts) {
-    return isHome(node, opts.homePageSlug)
-        ? "/"
-        : joinPath(chainOf(node, byId).map((n) => segmentFor(n, locale, opts.locales)));
+    return isHomeNode(node, opts) ? "/" : joinPath(chainOf(node, byId).map((n) => segmentFor(n, locale)));
+}
+/** The same path, or null when the node or an ancestor is absent from the
+ *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+export function pagePathIn(node, byId, locale, opts) {
+    if (!node.locales[locale])
+        return null;
+    if (isHomeNode(node, opts))
+        return "/";
+    const chain = chainOf(node, byId);
+    return chain.every((n) => n.locales[locale] !== undefined) ? joinPath(chain.map((n) => n.locales[locale].slug)) : null;
 }
+/** One row per locale the target EXISTS in. */
 export function pagePathRows(targets, byId, opts) {
     const rows = [];
     for (const target of targets) {
-        for (const locale of localesOf(target, opts.locales)) {
+        for (const locale of Object.keys(target.locales)) {
             rows.push({ kind: "page", id: target.id, locale, path: pagePath(target, byId, locale, opts) });
         }
     }
@@ -70,26 +97,32 @@ export function collectionSegment(path, locale, set) {
 }
 /** The "claims a URL" predicate (§1): a slug is only a real segment when
  * it is a non-empty string — absent, null, or `""` all mean "no URL".
- * The sibling index predicate in sql.ts (`entries_sibling_slug_key`)
- * mirrors this rule exactly, so Postgres and memory agree on which
+ * There is no sibling-slug index: sibling uniqueness is the primary key
+ * of `paths` plus the pre-check each store makes per locale before it
+ * writes (spec 2026-09-06 §12), so Postgres and memory agree on which
  * entries can collide. */
 export const slugOf = (fields) => {
     const slug = fields.slug;
     return typeof slug === "string" && slug.length > 0 ? slug : null;
 };
-export function entrySegment(entry, locale, set) {
-    const own = locale === set.default ? undefined : entry.i18n?.[locale]?.slug;
-    return typeof own === "string" && own.length > 0 ? own : slugOf(entry.fields);
+/** The entry's segment in one locale: its row's slug. An absent locale
+ *  or a slug-less row is null — no URL there, never a fallback. */
+export function entrySegment(entry, locale) {
+    return entry.locales[locale]?.slug ?? null;
 }
+/** One row per locale the target EXISTS in, where the whole chain has a
+ *  segment in that locale. The stores' parent rule guarantees an ancestor
+ *  is present wherever a descendant is; an ancestor without a slug there
+ *  simply yields no URL for the subtree in that locale. */
 export function entryPathRows(targets, byId, collection, set) {
     const rows = [];
     for (const target of targets) {
         const chain = chainOf(target, byId);
-        for (const locale of localesOf(target, set)) {
+        for (const locale of Object.keys(target.locales)) {
             const base = collectionSegment(collection.path, locale, set);
             if (base === null)
                 continue;
-            const segments = chain.map((e) => entrySegment(e, locale, set));
+            const segments = chain.map((e) => entrySegment(e, locale));
             if (segments.some((s) => s === null))
                 continue;
             rows.push({ kind: "entry", id: target.id, locale, path: joinPath([base, ...segments]) });
@@ -103,7 +136,7 @@ export function buildPageTree(records, locale, opts) {
         .filter((r) => r.parentId === parentId)
         .map((r) => ({
         record: r,
-        path: pagePath(r, byId, locale, opts),
+        path: pagePathIn(r, byId, locale, opts),
         children: build(r.id),
     }));
     return build(null);

package/dist/revalidate.js

@@ -32,7 +32,8 @@ export async function affectedTargets(stores, entryId, options = {}) {
     const published = [];
     for (const id of pageIds) {
         const page = await stores.pages.getPage(id);
-        if (page?.publishedVersionId)
+        // Published in ANY locale: the tag covers every locale's cached unit.
+        if (page && Object.values(page.locales).some((l) => l.status === "published"))
             published.push(id);
     }
     return { pageIds: published, entryIds };

package/dist/site.d.ts

@@ -23,13 +23,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>;

package/dist/site.js

@@ -1,6 +1,5 @@
-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";
 /** 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. */
@@ -20,42 +19,59 @@ 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, 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 +80,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,7 +164,7 @@ 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) });

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", "saved_sections", "global_sections", "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,13 @@ 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",
 ];
@@ -29,17 +32,22 @@ $$;`.trim();
  *  empty string means "read policy, no extra predicate" (global_sections
  *  is fully readable once it's in-space) — distinct from null. */
 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")`,
+    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")`,
     global_sections: ``,
     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')))`,
+    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", "saved_sections", "global_sections", "refs",
+];
 export function spaceLayerSQL() {
     const statements = [];
     statements.push(`