smoodly 0.0.6 → 0.0.7

package/dist/admin/shell/pages-tree.js

@@ -1,24 +1,57 @@
 // Pure view-model for the Pages list — the tree of the design system's
 // TreeTable (indent per depth, chevron on parents, the derived path as
-// the slug column). The shell is not DOM-tested; every decision that
+// the slug column) for ONE selected locale (spec 2026-09-06 §6). The
+// structure is shared, so every node has a row; presence is per locale,
+// so a node absent from the selected locale is dimmed with no path and
+// an "Add" action. The shell is not DOM-tested; every decision that
 // matters lives here.
-import { titleFor } from "../../localize.js";
 import { buildPageTree } from "../../paths.js";
 /** Registrations editors may create pages against: fixed ones are
  *  materialized by Smoodly, never offered. */
 export function openTemplates(templates) {
     return templates.filter((t) => t.slug === undefined);
 }
+/** The default-locale slug that identifies a ROOT node to the registry;
+ *  a root that exists in another locale only is never code-owned. */
+const rootSlug = (record, registry) => record.parentId === null ? record.locales[registry.locales.default]?.slug : undefined;
 /** The collection a ROOT record is the mount of, if any — known from the
  *  registry, never from a column (spec 2026-09-05 §4). */
 export function mountOf(record, registry) {
-    if (record.parentId !== null)
+    const slug = rootSlug(record, registry);
+    if (slug === undefined)
         return null;
-    return registry.collections.find((c) => c.path?.[registry.locales.default] === record.slug) ?? null;
+    return registry.collections.find((c) => c.path?.[registry.locales.default] === slug) ?? null;
 }
-/** Fixed pages and mounts: never renamed, moved or deleted by editors. */
+/** Fixed pages and mounts: never renamed, moved, deleted or stripped of a locale by editors. */
 export function isFixedNode(record, registry) {
-    return record.parentId === null && (registry.pages.some((t) => t.slug === record.slug) || mountOf(record, registry) !== null);
+    const slug = rootSlug(record, registry);
+    return slug !== undefined && (registry.pages.some((t) => t.slug === slug) || mountOf(record, registry) !== null);
+}
+/** A node's title for display in a locale it may not exist in: its own,
+ *  else the default locale's, else any. Display only — never content. */
+export function displayTitle(record, locale, registry) {
+    return (record.locales[locale]?.title ??
+        record.locales[registry.locales.default]?.title ??
+        Object.values(record.locales)[0]?.title ??
+        record.id);
+}
+/** The locale an "Add <locale>" copies from: the default when the node has it, else its first. */
+export function sourceLocaleOf(record, registry) {
+    return record.locales[registry.locales.default] ? registry.locales.default : Object.keys(record.locales)[0];
+}
+/** Whether a locale's row is live, and if so whether the draft has moved
+ *  on. `status` decides — spec 2026-09-06 §2 keeps it as a column so a
+ *  future unpublish can clear it while the version pointers stay — and
+ *  the pointers only tell "published" from "draft edits". The Pages list
+ *  and the editor's badge both read it here so they cannot disagree. */
+export function localeStatusOf(row) {
+    if (row.status !== "published")
+        return "draft";
+    // Pointers exist on pages and on versioned collections; a row without
+    // them is live as it stands.
+    if (row.publishedVersionId === null)
+        return "published";
+    return row.publishedVersionId === row.draftVersionId ? "published" : "draft edits";
 }
 export function pagesTreeRows(records, registry, locale, collapsed) {
     const opts = { locales: registry.locales, homePageSlug: registry.homePageSlug };
@@ -27,8 +60,10 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
     const walk = (nodes, depth, parentId) => {
         nodes.forEach((node, index) => {
             const r = node.record;
+            const row = r.locales[locale];
+            const present = row !== undefined;
             const mount = mountOf(r, registry);
-            const isHome = r.parentId === null && r.slug === registry.homePageSlug;
+            const isHome = r.parentId === null && r.locales[registry.locales.default]?.slug === registry.homePageSlug;
             const expanded = !collapsed.has(r.id);
             rows.push({
                 id: r.id,
@@ -38,8 +73,10 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
                 siblingCount: nodes.length,
                 hasChildren: node.children.length > 0,
                 expanded,
-                title: titleFor(r, locale, registry.locales),
+                title: displayTitle(r, locale, registry),
                 path: node.path,
+                present,
+                locales: Object.keys(r.locales),
                 kind: mount ? "mount" : r.template === null ? "folder" : "page",
                 collection: mount?.name ?? null,
                 fixed: isFixedNode(r, registry),
@@ -48,12 +85,9 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
                 templateTitle: mount
                     ? r.template === null ? "Collection" : `Collection · ${templateTitle(r.template)}`
                     : r.template === null ? "Folder" : templateTitle(r.template),
-                status: r.template === null
-                    ? null
-                    : r.publishedVersionId
-                        ? r.publishedVersionId === r.draftVersionId ? "published" : "draft edits"
-                        : "draft",
-                canHaveChildren: !mount && !isHome && depth + 1 < registry.pageDepth,
+                status: !row || r.template === null ? null : localeStatusOf(row),
+                // A child needs its parent in the locale (the parent rule), so an absent node offers none.
+                canHaveChildren: present && !mount && !isHome && depth + 1 < registry.pageDepth,
                 record: r,
             });
             if (expanded)

package/dist/admin/ui/LocaleSwitcher.d.ts

@@ -0,0 +1,11 @@
+import type { AdminRegistry } from "../serialize.ts";
+export declare function LocaleSwitcher({ registry, present, parentLocales, value, adding, onSwitch, onAdd }: {
+    registry: AdminRegistry;
+    /** The locales the record has; `[value]` while nothing is loaded. */
+    present: string[];
+    parentLocales: string[];
+    value: string;
+    adding: boolean;
+    onSwitch(locale: string): void;
+    onAdd(locale: string): void;
+}): import("react").JSX.Element;

package/dist/admin/ui/LocaleSwitcher.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function LocaleSwitcher({ registry, present, parentLocales, value, adding, onSwitch, onAdd }) {
+    const missing = registry.locales.supported.filter((l) => !present.includes(l) && l !== value);
+    return (_jsxs("select", { className: "sm-input", style: { width: "auto" }, value: value, "aria-label": "Locale", onChange: (e) => { const v = e.target.value; if (v.startsWith("+"))
+            onAdd(v.slice(1));
+        else
+            onSwitch(v); }, children: [present.map((l) => _jsx("option", { value: l, children: l }, l)), !present.includes(value) && _jsxs("option", { value: value, children: [value, " (not yet)"] }), missing.length > 0 && (_jsx("optgroup", { label: "Add locale", disabled: adding, children: missing.map((l) => {
+                    const blocked = !parentLocales.includes(l);
+                    const reason = `add ${l} to the parent first`;
+                    return blocked
+                        ? _jsxs("option", { value: `+${l}`, disabled: true, title: reason, children: ["+ ", l, " \u2014 ", reason] }, l)
+                        : _jsxs("option", { value: `+${l}`, children: ["+ ", l] }, l);
+                }) }))] }));
+}

package/dist/collections.d.ts

@@ -25,6 +25,11 @@ export type CollectionSchema<F extends BuilderMap = BuilderMap> = {
     admin?: {
         listColumns?: string[];
     };
+    /** Per-locale version history for this collection's entries (spec
+     *  2026-09-06 §7): every save becomes an `entry_versions` snapshot and
+     *  publish moves a pointer, as on pages. Off by default — a People list
+     *  does not want history; articles do. */
+    versions?: boolean;
     /** phantom: the entry value shape, used by f.ref target inference */
     readonly __entry?: NamespaceValues<F>;
 };
@@ -43,6 +48,7 @@ export declare function collection<F extends BuilderMap>(input: {
     admin?: {
         listColumns?: string[];
     };
+    versions?: boolean;
 }): CollectionSchema<F>;
 export type Toolset = {
     marks?: string[];

package/dist/collections.js

@@ -8,6 +8,15 @@ export function collection(input) {
     if (input.tree !== undefined && (!Number.isInteger(input.tree.depth) || input.tree.depth < 1)) {
         throw new Error(`smoodly: collection "${input.name}" declares an invalid tree depth.`);
     }
+    // `slug` is not a field on the node at all: splitFields drops it and the
+    // locale row owns it (spec 2026-09-06 §12), so ordering by it would be
+    // silently creation-ordered. Checked before the unknown-field check below
+    // so a collection with no declared `slug` field still gets this message,
+    // not "orders by an unknown field" — `slug` routes to the locale row
+    // whether or not it is declared.
+    if (input.order !== undefined && input.order !== "manual" && input.order.by === "slug") {
+        throw new Error(`smoodly: collection "${input.name}" orders by "slug", which is per locale — order fields are shared across locales.`);
+    }
     if (input.order !== undefined &&
         input.order !== "manual" &&
         !BUILT_IN_ORDER_FIELDS.includes(input.order.by) &&
@@ -17,6 +26,12 @@ export function collection(input) {
         !Object.prototype.hasOwnProperty.call(input.fields, input.order.by)) {
         throw new Error(`smoodly: collection "${input.name}" orders by an unknown field "${input.order.by}".`);
     }
+    if (input.order !== undefined &&
+        input.order !== "manual" &&
+        !BUILT_IN_ORDER_FIELDS.includes(input.order.by) &&
+        input.fields[input.order.by]?.descriptor.localized === true) {
+        throw new Error(`smoodly: collection "${input.name}" orders by "${input.order.by}", which is localized — order fields are shared across locales.`);
+    }
     return {
         kind: "collection",
         name: input.name,
@@ -26,6 +41,7 @@ export function collection(input) {
         ...(input.path !== undefined ? { path: input.path } : {}),
         ...(input.tree !== undefined ? { tree: input.tree } : {}),
         ...(input.order !== undefined ? { order: input.order } : {}),
+        ...(input.versions ? { versions: true } : {}),
         admin: input.admin,
     };
 }

package/dist/config.js

@@ -1,4 +1,4 @@
-import { assertSegment, perLocaleSegments } from "./paths.js";
+import { assertSegment, fixedPageSegments, perLocaleSegments } from "./paths.js";
 function assertUniqueNames(config) {
     const seen = new Set();
     const all = [
@@ -19,7 +19,11 @@ function assertUniqueNames(config) {
  *  EVERY locale of that path, which is the collection's index page. */
 function assertRootSegments(config) {
     const { default: def, supported } = config.locales;
+    // Mounts claim exactly the locales their path names; fixed pages fill an
+    // omitted locale from the default one, so the check must fill the same
+    // way the materializer does or the clash only shows up at materialization.
     const perLocale = (v) => perLocaleSegments(v, supported);
+    const pageSegments = (v) => fixedPageSegments(v, config.locales);
     const pages = (config.registry.pages ?? []).filter((p) => p.schema.kind === "page" && p.schema.slug !== undefined);
     const owners = new Map(); // "<locale> <segment>" → page name
     for (const p of pages) {
@@ -27,7 +31,7 @@ function assertRootSegments(config) {
         if (typeof slug !== "string" && slug[def] === undefined) {
             throw new Error(`smoodly: page "${p.schema.name}" declares a per-locale slug without the default locale "${def}".`);
         }
-        for (const [locale, segment] of Object.entries(perLocale(slug))) {
+        for (const [locale, segment] of Object.entries(pageSegments(slug))) {
             assertSegment(segment, `page "${p.schema.name}" fixed slug`);
             const owner = owners.get(`${locale} ${segment}`);
             if (owner) {
@@ -62,14 +66,30 @@ function assertRootSegments(config) {
             if (!pageName)
                 continue;
             const page = pages.find((p) => p.schema.name === pageName);
-            const everywhere = Object.entries(segments).every(([l, s]) => perLocale(page.schema.slug)[l] === s);
+            const everywhere = Object.entries(segments).every(([l, s]) => pageSegments(page.schema.slug)[l] === s);
             if (!everywhere) {
                 throw new Error(`smoodly: collection "${c.name}" and page registration "${pageName}" both claim the root segment "${segment}" (${locale}).`);
             }
         }
     }
 }
+/** A language subtag, optionally a script or region subtag (`en`, `fi`,
+ *  `en-US`, `zh-Hant`). Codes are otherwise opaque strings all the way
+ *  down — the paths key, the page_locales key — so the only place a
+ *  typo can be caught is here, at boot (spec 2026-09-06 §5). */
+const LOCALE_CODE_RE = /^[a-z]{2,3}(?:-[A-Za-z]{2,4})?$/;
+function assertLocales(config) {
+    const { default: def, supported } = config.locales;
+    for (const code of supported) {
+        if (!LOCALE_CODE_RE.test(code)) {
+            throw new Error(`smoodly: "${code}" is not a valid locale code — use a language tag like "en", "fi", "en-US" or "zh-Hant".`);
+        }
+    }
+    if (!supported.includes(def))
+        throw new Error(`smoodly: the default locale "${def}" is not in the supported list.`);
+}
 export function defineConfig(config) {
+    assertLocales(config);
     assertUniqueNames(config);
     assertRootSegments(config);
     const depth = config.pages?.tree?.depth ?? 1;

package/dist/entry-store.d.ts

@@ -1,19 +1,38 @@
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
+import { type RefEdge } from "./refs.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
 import { type LocaleSet, type PathTarget } from "./paths.ts";
+export type EntryLocale = {
+    /** The entry's segment in this locale; null claims no URL. */
+    slug: string | null;
+    status: "draft" | "published";
+    /** ONLY the .localized() fields, for this locale. */
+    fields: Record<string, unknown>;
+    draftVersionId: string | null;
+    publishedVersionId: string | null;
+    updatedAt: number;
+};
 export type EntryRecord = {
     id: string;
     collection: string;
     parentId: string | null;
+    /** The SHARED fields — every field without .localized(). */
     fields: Record<string, unknown>;
-    i18n: Record<string, Record<string, unknown>> | null;
-    status: "draft" | "published";
+    /** Only the locales present. Presence IS the row. */
+    locales: Record<string, EntryLocale>;
     sort: number | null;
-    locales: string[] | null;
     createdAt: number;
     updatedAt: number;
 };
+export type EntryVersion = {
+    id: string;
+    entryId: string;
+    locale: string;
+    /** The MERGED fields (shared + localized + slug) at that save. */
+    fields: Record<string, unknown>;
+    createdAt: number;
+};
 export type EntryUsage = {
     sourceKind: string;
     sourceId: string;
@@ -22,47 +41,65 @@ export type EntryUsage = {
 export type ListOptions = {
     /** Absent = the collection's configured order (config); `"manual"` sorts by `sort` asc. */
     order?: EntryOrder;
+    /** With `status`: the locale whose row is inspected; the default locale when omitted. */
+    locale?: string;
+    /** Only entries whose row in `locale` is published. */
     status?: "published";
     /**
      * `null` lists roots; a string id lists that parent's children; omitted
-     * (or explicitly `undefined`) applies no parent filter — everything in
-     * the collection, at every depth.
+     * (or explicitly `undefined`) applies no parent filter.
      */
     parent?: string | null;
 };
 export type CreateEntryOptions = {
+    locale: string;
     parentId?: string | null;
-    locales?: string[] | null;
+};
+export type AddEntryLocaleOptions = {
+    from: string;
 };
 export type EntryStoreOptions = {
     paths?: PathIndex;
     locales?: LocaleSet;
 };
 export interface EntryStore {
-    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
+    /** Creates the node and ONE locale row from the merged `fields`: shared
+     * keys go to the node, .localized() keys and `slug` to the row. The
+     * parent (if any) must exist in that locale. */
+    create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
-    /** Batched read for the resolver: fields keyed by id, missing ids omitted.
-     * The signature IS resolveTree's EntryFetcher. The published-route
-     * resolver passes { status: "published" } so an entry demoted to draft
-     * after a referencing page was published drops out on the next
-     * revalidation instead of hydrating draft fields (DESIGN.md OQ #16). */
-    getMany(collection: string, ids: string[], options?: {
+    /** Batched read for the resolver: the MERGED fields in `locale`, keyed
+     * by id. An id that is missing, absent in the locale, or (with
+     * `status`) unpublished there is omitted. With `{ status: "published" }`
+     * a versioned collection answers from the published snapshot, so a
+     * post-publish edit never leaks (DESIGN.md OQ #16). The signature,
+     * with the locale bound, IS resolveTree's EntryFetcher. */
+    getMany(collection: string, ids: string[], locale: string, options?: {
         status?: "published";
     }): Promise<Record<string, Record<string, unknown>>>;
-    update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    /** Replaces the merged fields for `locale`: shared keys on the node
+     * (every locale sees them), localized keys and the slug on the row. */
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<EntryRecord>;
+    /** Copies `from`'s localized fields and slug as the new row (shared
+     * fields need no copy); refused when the entry has the locale or its
+     * parent lacks it. */
+    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions): Promise<EntryRecord>;
+    /** Deletes the row, its versions and its paths rows; refused for the
+     * last locale and while a child has it. */
+    removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
+    /** Newest first; empty for a collection without `versions`. */
+    listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
     /** Blocked while anything references the entry (the safe-delete guard),
-     * and while it still has child entries. */
+     * and while it still has child entries. Removes every locale. */
     delete(collection: string, id: string): Promise<void>;
     /**
-     * Reparents `id` under `to.parentId`. `to.index` is the moved entry's
-     * final 0-based position among the destination siblings: the entry is
-     * removed from the sibling list first, then spliced back in at `index`.
-     * Omitted, it appends; out-of-range values clamp to [0, siblings.length].
-     * Destination siblings are renumbered 1..N afterward. Like `reorder`,
-     * `move` does NOT bump `updatedAt` — reparenting/resequencing is a
-     * structure change, not an edit to the entry's content.
+     * Reparents `id` under `to.parentId`, which must exist in every locale
+     * the entry has. `to.index` is the moved entry's final 0-based position
+     * among the destination siblings; omitted, it appends; out-of-range
+     * values clamp. Destination siblings are renumbered 1..N afterward.
+     * Like `reorder`, `move` does NOT bump `updatedAt`.
      */
     move(collection: string, id: string, to: {
         parentId: string | null;
@@ -72,8 +109,7 @@ export interface EntryStore {
     reorder(collection: string, orderedIds: string[]): Promise<void>;
     /** The refs index's reverse question: who points at this entry? */
     referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
-    /** Reverse lookup by id alone (ids are globally unique) — what the
-     * fan-out walk queries, since it can't know a source's collection. */
+    /** Reverse lookup by id alone (ids are globally unique) — the fan-out walk. */
     incoming(targetId: string): Promise<{
         sourceKind: string;
         sourceId: string;
@@ -88,63 +124,105 @@ export declare const entryErrors: {
     hasChildren: (collection: string, id: string) => Error;
     cycle: () => Error;
     foreignParent: () => Error;
-    /** 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: string) => Error;
+    unsupportedLocale: (locale: string) => Error;
+    notInLocale: (id: string, locale: string) => Error;
+    alreadyInLocale: (id: string, locale: string) => Error;
+    parentNotInLocale: (locale: string) => Error;
+    lastLocale: (id: string) => Error;
+    localeInUse: (locale: string, titles: string[]) => Error;
+    moveLocales: (locale: string) => Error;
+};
+/** 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 declare function localizedKeys(schema: CollectionSchema<any>): string[];
+export type SplitFields = {
+    shared: Record<string, unknown>;
+    localized: Record<string, unknown>;
+    slug: string | null;
 };
+/** 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 declare function splitFields(fields: Record<string, unknown>, schema: CollectionSchema<any>): SplitFields;
+export declare function entryLocaleRow(record: EntryRecord, locale: string): EntryLocale;
+/** The merged view of one locale: shared + that locale's fields + its
+ *  slug. A fresh object; throws for an absent locale. */
+export declare function entryFieldsIn(record: EntryRecord, locale: string): Record<string, unknown>;
+/** 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 declare function entryRefEdges(fieldSets: Record<string, unknown>[], schema: CollectionSchema<any>): RefEdge[];
+/** What a message calls an entry: its title field in that locale, else its id. */
+export declare function entryTitleIn(record: EntryRecord, locale: string, schema: CollectionSchema<any>): string;
 /**
- * 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 declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
 export declare class MemoryEntryStore implements EntryStore {
     private collections;
     private refs;
     private entries;
+    private versions;
+    /** Insertion order per version — `createdAt` alone can tie within a millisecond. */
+    private versionSeq;
     private seq;
     private order;
     private paths;
     private locales;
     constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex, options?: EntryStoreOptions);
+    private schema;
     private row;
     private must;
     private byId;
+    private snapshot;
     private subtree;
+    /** An edit bumps the node and the edited row; `move` and `reorder` never call this. */
+    private bump;
+    /** 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. */
+    private recordVersion;
+    private dropVersions;
+    /** 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). */
+    private liveFieldSets;
     private writePaths;
     private writeRefs;
     private siblings;
-    /** 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). */
+    /** 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. */
     private assertSiblingSlug;
+    /** Same collection, within depth. Returns the parent (null at the root). */
     private assertParent;
-    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
+    /** The parent rule: a locale can only be added where the parent has it. */
+    private assertParentHasLocale;
+    create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
-    getMany(collection: string, ids: string[], options?: {
+    getMany(collection: string, ids: string[], locale: string, options?: {
         status?: "published";
     }): Promise<Record<string, Record<string, unknown>>>;
-    update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<EntryRecord>;
+    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions): Promise<EntryRecord>;
+    removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
+    listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;