smoodly 0.0.6 → 0.0.7

package/dist/entry-store.js

@@ -1,16 +1,19 @@
 // The collection-entry persistence contract — the entries counterpart
-// to PageStore. Writes always flow through this API (never raw table
-// access), which is what lets the refs index stay correct: every save
-// rewrites the entry's outgoing edges (collectEntryRefs), so
-// referencesTo/safe-delete answer from the index alone. Status-only
-// versioning in v1 (DESIGN.md §3). Reorder rewrites sort 1..N in one
-// pass and NEVER touches updatedAt — order is a property of the
-// collection, not an edit to its entries.
+// to PageStore. An entry is ONE node (identity, tree position, the
+// SHARED fields) with one row per locale it exists in (spec 2026-09-06
+// §7): the locale row owns its slug, its publish state and the
+// .localized() fields, and — for a collection registered with
+// `versions: true` — a history of merged snapshots. Nothing falls back
+// to another locale. Writes always flow through this API (never raw
+// table access), which is what lets the refs index stay correct: every
+// save rewrites the entry's outgoing edges over EVERY locale's live
+// field set. Reorder rewrites sort 1..N in one pass and NEVER touches
+// updatedAt — order is a property of the collection, not an edit.
 import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
 import { MemoryPathIndex } from "./path-index.js";
-import { assertDepth, chainOf, entryPathRows, slugOf } from "./paths.js";
+import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, } from "./paths.js";
 export function schemaOf(collections, name) {
     const schema = collections.find((c) => c.name === name);
     if (!schema)
@@ -18,38 +21,89 @@ export function schemaOf(collections, name) {
     return schema;
 }
 let counter = 0;
-const uid = () => `entry-${++counter}-${Date.now().toString(36)}`;
+const uid = (prefix) => `${prefix}-${++counter}-${Date.now().toString(36)}`;
 export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
 export const entryErrors = {
     notFound: (collection, id) => new Error(`smoodly: no entry "${id}" in "${collection}".`),
     hasChildren: (collection, id) => new Error(`smoodly: "${collection}/${id}" has child entries — move or delete them first.`),
     cycle: () => new Error("smoodly: an entry cannot be moved under itself."),
     foreignParent: () => new Error("smoodly: the parent of an entry must be in the same collection."),
-    /** Entry slugs are unique among SIBLINGS (DESIGN.md §3, decided
-     *  2026-09-05): the same rule pages have, since the URL is the tree.
-     *  ONE source for the text — the Supabase adapter maps its
-     *  entries_sibling_slug_key 23505 onto this same error. */
+    /** Entry slugs are unique among SIBLINGS per locale — the rule pages
+     *  have (spec 2026-09-06 §11): both adapters pre-check in code and the
+     *  paths primary key is the invariant. ONE source for the text. */
     slugTaken: (collection) => new Error(`smoodly: a "${collection}" entry with that slug already exists under this parent.`),
+    unsupportedLocale,
+    notInLocale: (id, locale) => new Error(`smoodly: entry "${id}" does not exist in locale "${locale}".`),
+    alreadyInLocale: (id, locale) => new Error(`smoodly: entry "${id}" already exists in locale "${locale}".`),
+    parentNotInLocale: (locale) => new Error(`smoodly: the parent entry does not exist in locale "${locale}" — add it there first.`),
+    lastLocale: (id) => new Error(`smoodly: entry "${id}" must exist in at least one locale — delete the entry instead.`),
+    localeInUse: (locale, titles) => new Error(`smoodly: child entries 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 entry cannot move under it.`),
 };
+/** The keys a locale row owns: every field with .localized(), except
+ *  `slug`, which is the row's own column (a segment is an address, per
+ *  locale by nature). */
+export function localizedKeys(schema) {
+    return Object.entries(schema.fields)
+        .filter(([key, d]) => key !== "slug" && d.localized === true)
+        .map(([key]) => key);
+}
+/** The merged form an editor submits, split the way the tables store it.
+ *  Every key that is neither localized nor `slug` is shared — declared or
+ *  not — so a stray key never disappears into a locale row. */
+export function splitFields(fields, schema) {
+    const keys = new Set(localizedKeys(schema));
+    const shared = {};
+    const localized = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (key === "slug")
+            continue;
+        (keys.has(key) ? localized : shared)[key] = value;
+    }
+    return { shared: structuredClone(shared), localized: structuredClone(localized), slug: slugOf(fields) };
+}
+export function entryLocaleRow(record, locale) {
+    const row = record.locales[locale];
+    if (!row)
+        throw entryErrors.notInLocale(record.id, locale);
+    return row;
+}
+/** The merged view of one locale: shared + that locale's fields + its
+ *  slug. A fresh object; throws for an absent locale. */
+export function entryFieldsIn(record, locale) {
+    const row = entryLocaleRow(record, locale);
+    return {
+        ...structuredClone(record.fields),
+        ...structuredClone(row.fields),
+        ...(row.slug !== null ? { slug: row.slug } : {}),
+    };
+}
+/** The refs index rows for an entry: the union over every live field set
+ *  — one per present locale, plus each published snapshot the draft has
+ *  moved past. Safe-delete must hold while ANY of them shows the target,
+ *  since the published site still renders it (DESIGN.md §3 "Page edges
+ *  in refs", the same stance). */
+export function entryRefEdges(fieldSets, schema) {
+    const edges = [];
+    for (const fields of fieldSets)
+        edges.push(...collectEntryRefs(fields, schema));
+    return edges;
+}
+/** What a message calls an entry: its title field in that locale, else its id. */
+export function entryTitleIn(record, locale, schema) {
+    const value = schema.titleField && record.locales[locale] ? entryFieldsIn(record, locale)[schema.titleField] : undefined;
+    return typeof value === "string" && value.length > 0 ? value : record.id;
+}
 /**
- * Sort comparator for one order rule; `seq` breaks ties by creation.
- *
- * Nulls sort last in BOTH directions (the Supabase adapter must use
- * `nullsFirst: false` to match). The creation tiebreak follows `direction`
- * for non-manual orders — two entries created in the same millisecond
- * must still land newest-first under the default order, not oldest-first
- * — while the manual branch's tiebreak stays ascending (creation order
- * is the natural fallback for otherwise-unordered `sort` values).
+ * Sort comparator for one order rule; `seq` breaks ties by creation. A
+ * declared order field is SHARED (collection() refuses a localized one),
+ * so `e.fields[order.by]` reads the node. Nulls sort last in BOTH
+ * directions (the Supabase adapter uses `nullsFirst: false` to match);
+ * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
- * otherwise as strings via `localeCompare`. The Supabase adapter orders
- * by the jsonb VALUE (`fields->x`, decided 2026-09-05), so the two agree
- * for a field holding numbers and for one holding strings (ISO dates
- * included). Two edges still differ: MIXED types in one field — Postgres
- * orders jsonb by type first (null < string < number < boolean < array <
- * object) rather than by `String(...)` — and an explicit JSON `null`
- * VALUE, which is a jsonb null and sorts FIRST in Postgres but last here
- * (a MISSING key is SQL NULL and does sort last, matching). See the
- * package README's follow-ups.
+ * otherwise as strings via `localeCompare` — the same order Postgres
+ * gives the jsonb VALUE (`fields->x`) for one type; see the README's
+ * follow-ups for the mixed-type and JSON-null edges.
  */
 export function compareEntries(order, seq) {
     return (a, b) => {
@@ -77,12 +131,18 @@ export class MemoryEntryStore {
         this.collections = collections;
         this.refs = refs;
         this.entries = new Map();
-        this.seq = 0; // creation-order tiebreak (Date.now can tie)
+        this.versions = new Map();
+        /** Insertion order per version — `createdAt` alone can tie within a millisecond. */
+        this.versionSeq = new Map();
+        this.seq = 0;
         this.order = new Map();
         this.byId = (id) => this.entries.get(id);
         this.paths = options.paths ?? new MemoryPathIndex();
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
     }
+    schema(collection) {
+        return schemaOf(this.collections, collection);
+    }
     row(collection, id) {
         const entry = this.entries.get(id);
         return entry && entry.collection === collection ? entry : null;
@@ -93,6 +153,9 @@ export class MemoryEntryStore {
             throw entryErrors.notFound(collection, id);
         return entry;
     }
+    snapshot(entry) {
+        return structuredClone(entry);
+    }
     subtree(entry) {
         const out = [entry];
         const walk = (parentId) => {
@@ -105,54 +168,104 @@ export class MemoryEntryStore {
         walk(entry.id);
         return out;
     }
+    /** An edit bumps the node and the edited row; `move` and `reorder` never call this. */
+    bump(entry, row) {
+        const now = Date.now();
+        entry.updatedAt = now > entry.updatedAt ? now : entry.updatedAt + 1;
+        if (row)
+            row.updatedAt = entry.updatedAt;
+    }
+    /** A versioned collection records every save as a merged snapshot and
+     *  points the locale's draft at it; others keep the row as the live content. */
+    recordVersion(entry, locale) {
+        if (!this.schema(entry.collection).versions)
+            return;
+        const version = {
+            id: uid("version"), entryId: entry.id, locale, fields: entryFieldsIn(entry, locale), createdAt: Date.now(),
+        };
+        this.versions.set(version.id, version);
+        this.versionSeq.set(version.id, ++this.seq);
+        entry.locales[locale].draftVersionId = version.id;
+    }
+    dropVersions(entryId, locale) {
+        for (const [id, v] of this.versions) {
+            if (v.entryId === entryId && (locale === undefined || v.locale === locale)) {
+                this.versions.delete(id);
+                this.versionSeq.delete(id);
+            }
+        }
+    }
+    /** Every field set the site can render for this entry: each present
+     *  locale's live view, plus a published snapshot the draft has moved
+     *  past (still rendered by the published site). */
+    liveFieldSets(entry) {
+        const sets = [];
+        for (const [locale, row] of Object.entries(entry.locales)) {
+            sets.push(entryFieldsIn(entry, locale));
+            if (row.status === "published" && row.publishedVersionId && row.publishedVersionId !== row.draftVersionId) {
+                const snapshot = this.versions.get(row.publishedVersionId);
+                if (snapshot)
+                    sets.push(snapshot.fields);
+            }
+        }
+        return sets;
+    }
     async writePaths(collection, nodes) {
-        const schema = schemaOf(this.collections, collection);
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byId, schema, this.locales));
+        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byId, this.schema(collection), this.locales));
     }
-    writeRefs(collection, id, fields) {
-        const schema = schemaOf(this.collections, collection);
-        this.refs.rewrite({ sourceKind: "entry", sourceId: id }, collectEntryRefs(fields, schema));
+    writeRefs(entry) {
+        this.refs.rewrite({ sourceKind: "entry", sourceId: entry.id }, entryRefEdges(this.liveFieldSets(entry), this.schema(entry.collection)));
     }
     siblings(collection, parentId, except) {
         return [...this.entries.values()]
             .filter((e) => e.collection === collection && e.parentId === parentId && e.id !== except)
             .sort(compareEntries("manual", (e) => this.order.get(e.id)));
     }
-    /** The memory mirror of entries_sibling_slug_key: a string slug must be
-     *  unique among the entries sharing a parent. An absent, null or empty
-     *  slug claims no URL and never conflicts (the index's partial
-     *  predicate folds "" to null too via nullif). */
-    assertSiblingSlug(collection, parentId, fields, except) {
-        const slug = slugOf(fields);
+    /** The friendly pre-check (spec 2026-09-06 §11): a string slug must be
+     *  unique among the siblings PRESENT in that locale; null never
+     *  conflicts. The paths primary key remains the invariant. */
+    assertSiblingSlug(collection, parentId, locale, slug, except) {
         if (slug === null)
             return;
         for (const e of this.siblings(collection, parentId, except)) {
-            if (slugOf(e.fields) === slug)
+            if (e.locales[locale]?.slug === slug)
                 throw entryErrors.slugTaken(collection);
         }
     }
+    /** Same collection, within depth. Returns the parent (null at the root). */
     assertParent(collection, parentId, subtreeHeight) {
         if (parentId === null)
-            return;
+            return null;
         const parent = this.entries.get(parentId);
         if (!parent)
             throw entryErrors.notFound(collection, parentId);
         if (parent.collection !== collection)
             throw entryErrors.foreignParent();
-        assertDepth(chainOf(parent, this.byId).length + subtreeHeight, collectionDepth(schemaOf(this.collections, collection)), "the entry");
+        assertDepth(chainOf(parent, this.byId).length + subtreeHeight, collectionDepth(this.schema(collection)), "the entry");
+        return parent;
     }
-    async create(collection, fields, options = {}) {
-        schemaOf(this.collections, collection);
+    /** The parent rule: a locale can only be added where the parent has it. */
+    assertParentHasLocale(parent, locale) {
+        if (parent && !parent.locales[locale])
+            throw entryErrors.parentNotInLocale(locale);
+    }
+    async create(collection, fields, options) {
+        const schema = this.schema(collection);
+        assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
-        this.assertParent(collection, parentId, 1);
-        this.assertSiblingSlug(collection, parentId, fields);
+        const parent = this.assertParent(collection, parentId, 1);
+        this.assertParentHasLocale(parent, options.locale);
+        const { shared, localized, slug } = splitFields(fields, schema);
+        this.assertSiblingSlug(collection, parentId, options.locale, slug);
         const now = Date.now();
         const entry = {
-            id: uid(), collection, parentId,
-            fields: structuredClone(fields), i18n: null,
-            status: "draft", sort: null, locales: options.locales ?? null,
-            createdAt: now, updatedAt: now,
+            id: uid("entry"), collection, parentId, fields: shared,
+            locales: {
+                [options.locale]: { slug, status: "draft", fields: localized, draftVersionId: null, publishedVersionId: null, updatedAt: now },
+            },
+            sort: null, createdAt: now, updatedAt: now,
         };
+        this.recordVersion(entry, options.locale);
         this.entries.set(entry.id, entry);
         this.order.set(entry.id, ++this.seq);
         try {
@@ -161,61 +274,147 @@ export class MemoryEntryStore {
         catch (e) {
             this.entries.delete(entry.id);
             this.order.delete(entry.id);
+            this.dropVersions(entry.id);
             throw e;
         }
-        this.writeRefs(collection, entry.id, fields);
-        return structuredClone(entry);
+        this.writeRefs(entry);
+        return this.snapshot(entry);
     }
     async get(collection, id) {
         const entry = this.row(collection, id);
-        return entry ? structuredClone(entry) : null;
+        return entry ? this.snapshot(entry) : null;
     }
     async list(collection, options) {
-        const schema = schemaOf(this.collections, collection);
+        const schema = this.schema(collection);
         let rows = [...this.entries.values()].filter((e) => e.collection === collection);
-        if (options?.status)
-            rows = rows.filter((e) => e.status === options.status);
+        if (options?.status) {
+            const locale = options.locale ?? this.locales.default;
+            rows = rows.filter((e) => e.locales[locale]?.status === options.status);
+        }
         if (options?.parent !== undefined)
             rows = rows.filter((e) => e.parentId === options.parent);
         rows.sort(compareEntries(options?.order ?? collectionOrder(schema), (e) => this.order.get(e.id)));
-        return rows.map((e) => structuredClone(e));
+        return rows.map((e) => this.snapshot(e));
     }
-    async getMany(collection, ids, options) {
-        schemaOf(this.collections, collection);
+    async getMany(collection, ids, locale, options) {
+        this.schema(collection);
         const out = {};
         for (const id of ids) {
             const entry = this.row(collection, id);
-            if (!entry)
+            const row = entry?.locales[locale];
+            if (!entry || !row)
                 continue;
-            if (options?.status && entry.status !== options.status)
-                continue;
-            out[id] = structuredClone(entry.fields);
+            if (options?.status) {
+                if (row.status !== options.status)
+                    continue;
+                // A versioned collection serves what was published, not the live row.
+                const snapshot = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
+                out[id] = snapshot ? structuredClone(snapshot.fields) : entryFieldsIn(entry, locale);
+            }
+            else {
+                out[id] = entryFieldsIn(entry, locale);
+            }
         }
         return out;
     }
-    async update(collection, id, fields) {
+    async update(collection, id, locale, fields) {
+        const schema = this.schema(collection);
         const entry = this.must(collection, id);
-        this.assertSiblingSlug(collection, entry.parentId, fields, id);
-        const before = entry.fields;
-        entry.fields = structuredClone(fields);
+        const row = entryLocaleRow(entry, locale);
+        const { shared, localized, slug } = splitFields(fields, schema);
+        this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
+        const before = { fields: entry.fields, row: { ...row } };
+        entry.fields = shared;
+        row.fields = localized;
+        row.slug = slug;
         try {
             await this.writePaths(collection, this.subtree(entry));
         }
         catch (e) {
-            entry.fields = before;
+            entry.fields = before.fields;
+            Object.assign(row, before.row);
             throw e;
         }
-        entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
-        this.writeRefs(collection, id, fields);
-        return structuredClone(entry);
+        this.recordVersion(entry, locale);
+        this.bump(entry, row);
+        this.writeRefs(entry);
+        return this.snapshot(entry);
     }
-    async setStatus(collection, id, status) {
-        const entry = this.row(collection, id);
-        if (!entry)
-            throw entryErrors.notFound(collection, id);
-        entry.status = status;
-        entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
-        return structuredClone(entry);
+    async setStatus(collection, id, locale, status) {
+        const entry = this.must(collection, id);
+        const row = entryLocaleRow(entry, locale);
+        if (status === "published") {
+            // Publish points at the current draft; a versioned row always has one
+            // (create and update record it), but never trust that from here.
+            if (this.schema(collection).versions && !row.draftVersionId)
+                this.recordVersion(entry, locale);
+            row.publishedVersionId = row.draftVersionId;
+        }
+        // Unpublish keeps the pointer for a later republish (spec §2).
+        row.status = status;
+        this.bump(entry, row);
+        this.writeRefs(entry); // the published snapshot just became, or stopped being, a live set
+        return this.snapshot(entry);
+    }
+    async addLocale(collection, id, locale, options) {
+        assertSupportedLocale(locale, this.locales);
+        const entry = this.must(collection, id);
+        // The source is read FIRST: "copy from a locale that isn't there" is
+        // the more specific complaint, even when the target locale also exists.
+        const source = entryLocaleRow(entry, options.from);
+        if (entry.locales[locale])
+            throw entryErrors.alreadyInLocale(id, locale);
+        const parent = entry.parentId === null ? null : (this.entries.get(entry.parentId) ?? null);
+        this.assertParentHasLocale(parent, locale);
+        this.assertSiblingSlug(collection, entry.parentId, locale, source.slug, id);
+        const now = Date.now();
+        entry.locales[locale] = {
+            slug: source.slug, status: "draft", fields: structuredClone(source.fields),
+            draftVersionId: null, publishedVersionId: null, updatedAt: now,
+        };
+        this.recordVersion(entry, locale);
+        // Only this node's rows change: a child cannot have a locale its parent lacked.
+        try {
+            await this.writePaths(collection, [entry]);
+        }
+        catch (e) {
+            delete entry.locales[locale];
+            this.dropVersions(id, locale);
+            throw e;
+        }
+        this.writeRefs(entry);
+        return this.snapshot(entry);
+    }
+    async removeLocale(collection, id, locale) {
+        const schema = this.schema(collection);
+        const entry = this.must(collection, id);
+        const row = entryLocaleRow(entry, locale);
+        if (Object.keys(entry.locales).length === 1)
+            throw entryErrors.lastLocale(id);
+        const blockers = [...this.entries.values()]
+            .filter((e) => e.parentId === id && e.locales[locale] !== undefined)
+            .map((e) => entryTitleIn(e, locale, schema));
+        if (blockers.length > 0)
+            throw entryErrors.localeInUse(locale, blockers);
+        delete entry.locales[locale];
+        try {
+            await this.writePaths(collection, [entry]);
+        }
+        catch (e) {
+            entry.locales[locale] = row;
+            throw e;
+        }
+        this.dropVersions(id, locale);
+        this.bump(entry);
+        this.writeRefs(entry);
+        return this.snapshot(entry);
+    }
+    async listVersions(collection, id, locale) {
+        this.must(collection, id);
+        return [...this.versions.values()]
+            .filter((v) => v.entryId === id && v.locale === locale)
+            .sort((a, b) => b.createdAt - a.createdAt || this.versionSeq.get(b.id) - this.versionSeq.get(a.id))
+            .map((v) => structuredClone(v));
     }
     async move(collection, id, to) {
         const entry = this.must(collection, id);
@@ -223,9 +422,16 @@ export class MemoryEntryStore {
         if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
             throw entryErrors.cycle();
         const height = Math.max(...subtree.map((e) => chainOf(e, this.byId).length)) - chainOf(entry, this.byId).length + 1;
-        this.assertParent(collection, to.parentId, height);
-        if (to.parentId !== entry.parentId)
-            this.assertSiblingSlug(collection, to.parentId, entry.fields, id);
+        const parent = this.assertParent(collection, to.parentId, height);
+        // The destination must have every locale the entry has, or a chain breaks there.
+        if (parent)
+            for (const locale of Object.keys(entry.locales))
+                if (!parent.locales[locale])
+                    throw entryErrors.moveLocales(locale);
+        if (to.parentId !== entry.parentId) {
+            for (const [locale, row] of Object.entries(entry.locales))
+                this.assertSiblingSlug(collection, to.parentId, locale, row.slug, id);
+        }
         const before = { parentId: entry.parentId, sort: entry.sort };
         entry.parentId = to.parentId;
         const siblings = this.siblings(collection, to.parentId, id);
@@ -242,7 +448,7 @@ export class MemoryEntryStore {
                 s.sort = previous.get(s.id) ?? null;
             throw e;
         }
-        return structuredClone(entry);
+        return this.snapshot(entry);
     }
     async delete(collection, id) {
         const entry = this.row(collection, id);
@@ -256,10 +462,12 @@ export class MemoryEntryStore {
         }
         await this.paths.remove([{ kind: "entry", id }]);
         this.entries.delete(id);
+        this.order.delete(id);
+        this.dropVersions(id);
         this.refs.remove({ sourceKind: "entry", sourceId: id });
     }
     async reorder(collection, orderedIds) {
-        schemaOf(this.collections, collection);
+        this.schema(collection);
         orderedIds.forEach((id, i) => {
             const entry = this.row(collection, id);
             if (entry)

package/dist/index.d.ts

@@ -22,17 +22,17 @@ export type { PathIndex } from "./path-index.ts";
 export { MemoryEntryStore } from "./entry-store.ts";
 export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
-export type { EntryStore, EntryRecord, EntryUsage, ListOptions, CreateEntryOptions, EntryStoreOptions } from "./entry-store.ts";
-export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES } from "./entry-store.ts";
+export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, } from "./entry-store.ts";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.ts";
 export { affectedTargets, pageTag, entryTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions } from "./resolve.ts";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, localesOf, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, } from "./paths.ts";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.ts";
 export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions } from "./paths.ts";
-export { titleFor, localizeFields, fixedPathFor } from "./localize.ts";
-export type { PageStore, PageRecord, PageVersion, PageStoreOptions, PageI18n, CreatePageInput } from "./store.ts";
-export { pathOptions, pageErrors, assertPageI18n, DEFAULT_LOCALES } from "./store.ts";
+export { fixedPathFor } from "./localize.ts";
+export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
+export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
 export type { FieldBuilder, Descriptor, ValueOf } from "./fields.ts";
 export type { SectionSchema, ElementSchema, BuilderMap } from "./schema.ts";

package/dist/index.js

@@ -18,12 +18,12 @@ export { MemoryPathIndex } from "./path-index.js";
 export { MemoryEntryStore } from "./entry-store.js";
 export { SupabaseEntryStore } from "./supabase-entry-store.js";
 export { SupabasePathIndex } from "./supabase-path-index.js";
-export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES } from "./entry-store.js";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.js";
 export { affectedTargets, pageTag, entryTag } from "./revalidate.js";
 export { resolveTree, resolveFields } from "./resolve.js";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, localesOf, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, } from "./paths.js";
-export { titleFor, localizeFields, fixedPathFor } from "./localize.js";
-export { pathOptions, pageErrors, assertPageI18n, DEFAULT_LOCALES } from "./store.js";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.js";
+export { fixedPathFor } from "./localize.js";
+export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
 export const smoodly = {
     schema,

package/dist/localize.d.ts

@@ -1,15 +1,4 @@
 import { type LocaleSet } from "./paths.ts";
-/** The locale's title, or the default locale's. */
-export declare function titleFor(node: {
-    title: string;
-    i18n?: Record<string, {
-        title?: string;
-    }> | null;
-}, locale: string, set: LocaleSet): string;
-/** A fresh object: the default locale's fields, overlaid per field with
- *  the locale's values. An overlay value that is undefined, null or ""
- *  falls back — a translator may leave a field blank. */
-export declare function localizeFields(fields: Record<string, unknown>, i18n: Record<string, Record<string, unknown>> | null | undefined, locale: string, set: LocaleSet): Record<string, unknown>;
 /** The path a FIXED page registration is served at in one locale — the
  *  escape hatch's addressing (spec §5: renderSmoodlyPage). Home is judged
  *  by the default-locale segment, exactly as the stores judge the record. */

package/dist/localize.js

@@ -1,29 +1,8 @@
-// Per-field locale fallback for the two overlays the stores carry
-// (spec 2026-09-05 §2): `pages.i18n[locale].title` and
-// `entries.i18n[locale]`. Slugs are paths.ts's business (segmentFor);
-// this module owns titles and entry fields. Pure and framework-free.
-import { segmentFor } from "./paths.js";
-const present = (v) => v !== undefined && v !== null && v !== "";
-/** The locale's title, or the default locale's. */
-export function titleFor(node, locale, set) {
-    if (locale === set.default)
-        return node.title;
-    const own = node.i18n?.[locale]?.title;
-    return typeof own === "string" && own.length > 0 ? own : node.title;
-}
-/** A fresh object: the default locale's fields, overlaid per field with
- *  the locale's values. An overlay value that is undefined, null or ""
- *  falls back — a translator may leave a field blank. */
-export function localizeFields(fields, i18n, locale, set) {
-    const out = structuredClone(fields);
-    if (locale === set.default)
-        return out;
-    for (const [key, value] of Object.entries(i18n?.[locale] ?? {})) {
-        if (present(value))
-            out[key] = structuredClone(value);
-    }
-    return out;
-}
+// The fixed-page path derivation — the escape hatch's addressing (spec
+// 2026-09-05 §5). Entries and pages alike have no field fallback: their
+// locale rows own their fields, titles and slugs (spec 2026-09-06). This
+// module owns nothing but fixedPathFor now.
+import { fixedPageSegments } from "./paths.js";
 /** The path a FIXED page registration is served at in one locale — the
  *  escape hatch's addressing (spec §5: renderSmoodlyPage). Home is judged
  *  by the default-locale segment, exactly as the stores judge the record. */
@@ -31,12 +10,15 @@ export function fixedPathFor(schema, locale, set, homePageSlug) {
     if (schema.slug === undefined) {
         throw new Error(`smoodly: page registration "${schema.name}" has no fixed slug — open pages are served by renderSmoodlyPath.`);
     }
-    const slug = typeof schema.slug === "string" ? schema.slug : schema.slug[set.default];
+    // A registration declares its slugs in code, so a locale it omits means
+    // "the same segment", not "absent" — paths.ts's fixedPageSegments fills
+    // it, the same fill the boot check and the materializer use.
+    const segments = fixedPageSegments(schema.slug, set);
+    const slug = segments[set.default];
     if (slug === undefined) {
         throw new Error(`smoodly: page registration "${schema.name}" declares a per-locale slug without the default locale "${set.default}".`);
     }
     if (slug === homePageSlug)
         return "/";
-    const i18n = typeof schema.slug === "string" ? null : Object.fromEntries(Object.entries(schema.slug).map(([l, s]) => [l, { slug: s }]));
-    return `/${segmentFor({ slug, i18n }, locale, set)}`;
+    return `/${segments[locale] ?? slug}`;
 }