smoodly 0.0.6 → 0.0.7

package/dist/supabase-entry-store.js

@@ -1,33 +1,46 @@
-// The Supabase adapter for the EntryStore contract, over entries + refs.
-// Service-role client, server-side only (writes bypass RLS by design —
-// DESIGN.md §1). Reorder calls the smoodly_reorder SQL function: one
-// statement for the whole collection, updated_at untouched.
+// The Supabase adapter for the EntryStore contract, over entries +
+// entry_locales + entry_versions + refs + paths. Service-role client (or
+// a cloud write key), server-side only. Every read embeds the locale
+// rows (`*, entry_locales(*)`) so a record arrives whole; a versioned
+// collection's published read goes through entry_versions. Path rows are
+// rewritten through ONE RPC per write, so a collision rolls back. Reorder
+// calls the smoodly_reorder SQL function: one statement, updated_at
+// untouched.
 import { collectionDepth, collectionOrder } from "./collections.js";
-import { DEFAULT_ENTRY_LOCALES, entryErrors, schemaOf } from "./entry-store.js";
-import { collectEntryRefs } from "./refs.js";
+import { DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, schemaOf, splitFields, } from "./entry-store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
-import { assertDepth, entryPathRows, slugOf } from "./paths.js";
+import { assertDepth, assertSupportedLocale, entryPathRows } from "./paths.js";
 // entries.id is a Postgres uuid column: filtering on a non-UUID string
 // throws invalid_text_representation. A non-UUID id can't exist in the
-// table, so treat it the same as a missing one — getMany silently omits
-// it, patch raises the contract's "no entry" error — rather than letting
-// the cast error leak through.
+// table, so treat it the same as a missing one.
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const UNIQUE_VIOLATION = "23505";
+const SELECT = "*, entry_locales(*)";
+function toLocale(row) {
+    return {
+        slug: row.slug,
+        status: row.status,
+        fields: row.fields,
+        draftVersionId: row.draft_version_id,
+        publishedVersionId: row.published_version_id,
+        updatedAt: Date.parse(row.updated_at),
+    };
+}
 function toRecord(row) {
     return {
         id: row.id,
         collection: row.collection,
         parentId: row.parent_id,
         fields: row.fields,
-        i18n: row.i18n,
-        status: row.status,
+        locales: Object.fromEntries((row.entry_locales ?? []).map((l) => [l.locale, toLocale(l)])),
         sort: row.sort,
-        locales: row.locales,
         createdAt: Date.parse(row.created_at),
         updatedAt: Date.parse(row.updated_at),
     };
 }
+function toVersion(row) {
+    return { id: row.id, entryId: row.entry_id, locale: row.locale, fields: row.fields, createdAt: Date.parse(row.created_at) };
+}
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
         this.db = db;
@@ -38,42 +51,31 @@ export class SupabaseEntryStore {
     fail(message) {
         throw new Error(`smoodly: ${message}`);
     }
-    // entries_sibling_slug_key (space_id, collection, parent_id,
-    // fields->>'slug') enforces slug uniqueness among SIBLINGS at the DB
-    // level, ahead of the paths rewrite — a collision here never reaches
-    // writePaths, so the insert, the update and move's re-parent all need
-    // this translation. The text comes from entryErrors so the memory
-    // adapter's pre-check and this one read identically.
-    failWriteError(error, collection) {
-        if (error.code === UNIQUE_VIOLATION)
-            throw entryErrors.slugTaken(collection);
-        this.fail(error.message);
-    }
-    async writeRefs(collection, id, fields) {
-        const schema = schemaOf(this.collections, collection);
-        const deleted = await this.db
-            .from("refs")
-            .delete()
-            .eq("source_kind", "entry")
-            .eq("source_id", id);
-        if (deleted.error)
-            this.fail(deleted.error.message);
-        // dedupe: the refs PK is (source_kind, source_id, source_field, target_id)
-        const rows = new Map();
-        for (const edge of collectEntryRefs(fields, schema)) {
-            rows.set(`${edge.field}\x00${edge.targetId}`, {
-                source_kind: "entry",
-                source_id: id,
-                source_field: edge.field,
-                target_collection: edge.targetCollection,
-                target_id: edge.targetId,
-            });
-        }
-        if (rows.size > 0) {
-            const inserted = await this.db.from("refs").insert([...rows.values()]);
-            if (inserted.error)
-                this.fail(inserted.error.message);
-        }
+    schema(collection) {
+        return schemaOf(this.collections, collection);
+    }
+    // ── reads ──
+    async fetch(collection, id) {
+        if (!UUID_RE.test(id))
+            return null;
+        const res = await this.db.from("entries").select(SELECT).eq("collection", collection).eq("id", id).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data ? toRecord(res.data) : null;
+    }
+    async must(collection, id) {
+        const entry = await this.fetch(collection, id);
+        if (!entry)
+            throw entryErrors.notFound(collection, id);
+        return entry;
+    }
+    async siblings(collection, parentId, except) {
+        let query = this.db.from("entries").select(SELECT).eq("collection", collection);
+        query = parentId === null ? query.is("parent_id", null) : query.eq("parent_id", parentId);
+        const res = await query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true });
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toRecord).filter((e) => e.id !== except);
     }
     byIdMap(rows) {
         const map = new Map(rows.map((r) => [r.id, r]));
@@ -83,7 +85,7 @@ export class SupabaseEntryStore {
         const chain = [entry];
         let current = entry;
         while (current.parentId !== null) {
-            const parent = await this.get(current.collection, current.parentId);
+            const parent = await this.fetch(current.collection, current.parentId);
             if (!parent)
                 this.fail(`broken parent chain at "${entry.id}".`);
             chain.unshift(parent);
@@ -95,7 +97,7 @@ export class SupabaseEntryStore {
         const out = [entry];
         let frontier = [entry.id];
         while (frontier.length > 0) {
-            const res = await this.db.from("entries").select("*").eq("collection", entry.collection).in("parent_id", frontier);
+            const res = await this.db.from("entries").select(SELECT).eq("collection", entry.collection).in("parent_id", frontier);
             if (res.error)
                 this.fail(res.error.message);
             const rows = res.data.map(toRecord);
@@ -104,18 +106,75 @@ export class SupabaseEntryStore {
         }
         return out;
     }
+    async versionFields(ids) {
+        if (ids.length === 0)
+            return new Map();
+        const res = await this.db.from("entry_versions").select("id, fields").in("id", ids);
+        if (res.error)
+            this.fail(res.error.message);
+        return new Map(res.data.map((r) => [r.id, r.fields]));
+    }
+    // ── the derived indexes ──
     async writePaths(top) {
-        const schema = schemaOf(this.collections, top.collection);
+        const schema = this.schema(top.collection);
         const ancestors = await this.chain(top);
         const nodes = await this.subtree(top);
         await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
     }
+    /** Every field set the site can render: each locale's live view, plus a
+     *  published snapshot the draft has moved past (see entryRefEdges). */
+    async liveFieldSets(entry) {
+        const sets = [];
+        const snapshotIds = [];
+        for (const [locale, row] of Object.entries(entry.locales)) {
+            sets.push(entryFieldsIn(entry, locale));
+            if (row.status === "published" && row.publishedVersionId && row.publishedVersionId !== row.draftVersionId) {
+                snapshotIds.push(row.publishedVersionId);
+            }
+        }
+        for (const fields of (await this.versionFields(snapshotIds)).values())
+            sets.push(fields);
+        return sets;
+    }
+    async writeRefs(entry) {
+        const schema = this.schema(entry.collection);
+        const deleted = await this.db.from("refs").delete().eq("source_kind", "entry").eq("source_id", entry.id);
+        if (deleted.error)
+            this.fail(deleted.error.message);
+        // dedupe: the refs PK is (source_kind, source_id, source_field, target_id)
+        const rows = new Map();
+        for (const edge of entryRefEdges(await this.liveFieldSets(entry), schema)) {
+            rows.set(`${edge.field}\x00${edge.targetId}`, {
+                source_kind: "entry",
+                source_id: entry.id,
+                source_field: edge.field,
+                target_collection: edge.targetCollection,
+                target_id: edge.targetId,
+            });
+        }
+        if (rows.size > 0) {
+            const inserted = await this.db.from("refs").insert([...rows.values()]);
+            if (inserted.error)
+                this.fail(inserted.error.message);
+        }
+    }
+    // ── guards ──
+    /** The friendly pre-check per locale (spec 2026-09-06 §11); the paths
+     *  primary key is the invariant. */
+    async assertSiblingSlug(collection, parentId, locale, slug, except) {
+        if (slug === null)
+            return;
+        for (const s of await this.siblings(collection, parentId, except)) {
+            if (s.locales[locale]?.slug === slug)
+                throw entryErrors.slugTaken(collection);
+        }
+    }
     async assertParent(collection, parentId, subtreeHeight) {
         if (parentId === null)
-            return;
+            return null;
         if (!UUID_RE.test(parentId))
             throw entryErrors.notFound(collection, parentId);
-        const res = await this.db.from("entries").select("*").eq("id", parentId).maybeSingle();
+        const res = await this.db.from("entries").select(SELECT).eq("id", parentId).maybeSingle();
         if (res.error)
             this.fail(res.error.message);
         if (!res.data)
@@ -123,52 +182,96 @@ export class SupabaseEntryStore {
         const parent = toRecord(res.data);
         if (parent.collection !== collection)
             throw entryErrors.foreignParent();
-        assertDepth((await this.chain(parent)).length + subtreeHeight, collectionDepth(schemaOf(this.collections, collection)), "the entry");
+        assertDepth((await this.chain(parent)).length + subtreeHeight, collectionDepth(this.schema(collection)), "the entry");
+        return parent;
     }
-    async create(collection, fields, options = {}) {
-        schemaOf(this.collections, collection);
-        const parentId = options.parentId ?? null;
-        await this.assertParent(collection, parentId, 1);
+    assertParentHasLocale(parent, locale) {
+        if (parent && !parent.locales[locale])
+            throw entryErrors.parentNotInLocale(locale);
+    }
+    // ── row writers ──
+    // `touch` defaults to true (an edit bumps updated_at). A rollback or a
+    // structure change passes { touch: false } so the column is left alone.
+    async updateNode(id, patch, options = {}) {
+        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const res = await this.db.from("entries").update(payload).eq("id", id);
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    async insertLocale(entryId, locale, row) {
+        const res = await this.db.from("entry_locales").insert({ entry_id: entryId, locale, slug: row.slug, fields: row.fields });
+        if (res.error) {
+            if (res.error.code === UNIQUE_VIOLATION)
+                throw entryErrors.alreadyInLocale(entryId, locale);
+            this.fail(res.error.message);
+        }
+    }
+    async updateLocale(entryId, locale, patch, options = {}) {
+        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const res = await this.db.from("entry_locales").update(payload).eq("entry_id", entryId).eq("locale", locale);
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    /** The row goes first (it is what makes the entry exist in the locale), then its versions. */
+    async deleteLocale(entryId, locale) {
+        const row = await this.db.from("entry_locales").delete().eq("entry_id", entryId).eq("locale", locale);
+        if (row.error)
+            this.fail(row.error.message);
+        const versions = await this.db.from("entry_versions").delete().eq("entry_id", entryId).eq("locale", locale);
+        if (versions.error)
+            this.fail(versions.error.message);
+    }
+    /** A versioned collection snapshots the merged fields and points the
+     *  locale's draft at the new row; others do nothing here. */
+    async recordVersion(entry, locale) {
+        if (!this.schema(entry.collection).versions)
+            return;
         const res = await this.db
-            .from("entries")
-            .insert({ collection, fields, parent_id: parentId, locales: options.locales ?? null })
-            .select("*")
+            .from("entry_versions")
+            .insert({ entry_id: entry.id, locale, fields: entryFieldsIn(entry, locale) })
+            .select("id")
             .single();
         if (res.error)
-            this.failWriteError(res.error, collection);
-        const row = toRecord(res.data);
+            this.fail(res.error.message);
+        await this.updateLocale(entry.id, locale, { draft_version_id: res.data.id }, { touch: false });
+    }
+    // ── the contract ──
+    async create(collection, fields, options) {
+        const schema = this.schema(collection);
+        assertSupportedLocale(options.locale, this.locales);
+        const parentId = options.parentId ?? null;
+        const parent = await this.assertParent(collection, parentId, 1);
+        this.assertParentHasLocale(parent, options.locale);
+        const { shared, localized, slug } = splitFields(fields, schema);
+        await this.assertSiblingSlug(collection, parentId, options.locale, slug);
+        const inserted = await this.db.from("entries").insert({ collection, parent_id: parentId, fields: shared }).select("id").single();
+        if (inserted.error)
+            this.fail(inserted.error.message);
+        const id = inserted.data.id;
         try {
-            await this.writePaths(row);
+            await this.insertLocale(id, options.locale, { slug, fields: localized });
+            let record = await this.must(collection, id);
+            await this.recordVersion(record, options.locale);
+            record = await this.must(collection, id);
+            await this.writePaths(record);
+            await this.writeRefs(record);
+            return record;
         }
         catch (e) {
-            await this.db.from("entries").delete().eq("id", row.id);
+            // Everything hangs off the node: locale rows and versions cascade.
+            // `paths` does not — it has no FK — and writeRefs runs AFTER the
+            // rewrite, so clear the rows first, the order `delete` uses.
+            await this.paths.remove([{ kind: "entry", id }]);
+            await this.db.from("entries").delete().eq("id", id);
             throw e;
         }
-        await this.writeRefs(collection, row.id, fields);
-        return row;
     }
     async get(collection, id) {
-        // Same short-circuit as UUID_RE elsewhere: a non-UUID id can't exist
-        // in the table, and querying it as one throws invalid_text_representation
-        // instead of returning "not found" (which `update`'s rollback read and
-        // `chain`'s parent walk both rely on).
-        if (!UUID_RE.test(id))
-            return null;
-        const res = await this.db
-            .from("entries")
-            .select("*")
-            .eq("collection", collection)
-            .eq("id", id)
-            .maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? toRecord(res.data) : null;
+        return this.fetch(collection, id);
     }
     async list(collection, options) {
-        const schema = schemaOf(this.collections, collection);
-        let query = this.db.from("entries").select("*").eq("collection", collection);
-        if (options?.status)
-            query = query.eq("status", options.status);
+        const schema = this.schema(collection);
+        let query = this.db.from("entries").select(SELECT).eq("collection", collection);
         if (options?.parent !== undefined) {
             query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
         }
@@ -177,131 +280,197 @@ export class SupabaseEntryStore {
             query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true });
         }
         else {
-            // `fields->x`, not `->>x`: ordering by the jsonb VALUE, so numbers
-            // compare numerically (rank 10 after rank 2) and strings — ISO dates
-            // included — alphabetically, matching the memory comparator.
+            // `fields->x`, not `->>x`: ordering by the jsonb VALUE of the SHARED
+            // field (an order field is never localized), matching the memory comparator.
             const column = order.by === "createdAt" ? "created_at" : order.by === "updatedAt" ? "updated_at" : `fields->${order.by}`;
             query = query.order(column, { ascending: order.direction === "asc", nullsFirst: false }).order("id", { ascending: true });
         }
         const res = await query;
         if (res.error)
             this.fail(res.error.message);
-        return res.data.map(toRecord);
+        let rows = res.data.map(toRecord);
+        // The status filter reads the locale row; collections are small enough
+        // to filter here rather than lose the other rows to an !inner embed.
+        if (options?.status) {
+            const locale = options.locale ?? this.locales.default;
+            rows = rows.filter((e) => e.locales[locale]?.status === options.status);
+        }
+        return rows;
     }
-    async getMany(collection, ids, options) {
-        schemaOf(this.collections, collection);
+    async getMany(collection, ids, locale, options) {
+        this.schema(collection);
         const uuidIds = ids.filter((id) => UUID_RE.test(id));
         if (uuidIds.length === 0)
             return {};
-        let query = this.db
-            .from("entries")
-            .select("id, fields")
-            .eq("collection", collection)
-            .in("id", uuidIds);
-        if (options?.status)
-            query = query.eq("status", options.status);
-        const res = await query;
+        const res = await this.db.from("entries").select(SELECT).eq("collection", collection).in("id", uuidIds);
         if (res.error)
             this.fail(res.error.message);
+        const records = res.data.map(toRecord);
         const out = {};
-        for (const row of res.data) {
-            out[row.id] = row.fields;
+        if (!options?.status) {
+            for (const record of records)
+                if (record.locales[locale])
+                    out[record.id] = entryFieldsIn(record, locale);
+            return out;
+        }
+        const published = records.filter((r) => r.locales[locale]?.status === options.status);
+        // A versioned collection serves what was published, not the live row.
+        const snapshots = await this.versionFields(published.map((r) => r.locales[locale].publishedVersionId).filter((v) => v !== null));
+        for (const record of published) {
+            const pointer = record.locales[locale].publishedVersionId;
+            out[record.id] = (pointer !== null ? snapshots.get(pointer) : undefined) ?? entryFieldsIn(record, locale);
         }
         return out;
     }
-    // `touch` defaults to true (the normal edit path always bumps
-    // updated_at). Callers that must leave the timestamp alone — a
-    // rollback restoring a prior value, or move's re-parent, which the
-    // contract says must not count as an edit — pass `{ touch: false }`,
-    // which omits updated_at from the payload entirely so the column is
-    // left untouched (or keeps whatever value the caller put in `patch`).
-    async patch(collection, id, patch, options = {}) {
-        if (!UUID_RE.test(id))
-            throw entryErrors.notFound(collection, id);
-        const touch = options.touch ?? true;
-        const payload = touch ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
-        const res = await this.db
-            .from("entries")
-            .update(payload)
-            .eq("collection", collection)
-            .eq("id", id)
-            .select("*")
-            .maybeSingle();
-        if (res.error)
-            this.failWriteError(res.error, collection);
-        if (!res.data)
-            throw entryErrors.notFound(collection, id);
-        return toRecord(res.data);
-    }
-    async update(collection, id, fields) {
-        const before = await this.get(collection, id);
-        if (!before)
-            throw entryErrors.notFound(collection, id);
-        const record = await this.patch(collection, id, { fields });
+    async update(collection, id, locale, fields) {
+        const schema = this.schema(collection);
+        const before = await this.must(collection, id);
+        const row = entryLocaleRow(before, locale);
+        const { shared, localized, slug } = splitFields(fields, schema);
+        await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
+        await this.updateNode(id, { fields: shared });
+        await this.updateLocale(id, locale, { slug, fields: localized });
+        const record = await this.must(collection, id);
         try {
             await this.writePaths(record);
         }
         catch (e) {
-            await this.patch(collection, id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
+            await this.updateNode(id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
+            await this.updateLocale(id, locale, { slug: row.slug, fields: row.fields, updated_at: new Date(row.updatedAt).toISOString() }, { touch: false });
             throw e;
         }
-        await this.writeRefs(collection, id, fields);
-        return record;
+        await this.recordVersion(record, locale);
+        const final = await this.must(collection, id);
+        await this.writeRefs(final);
+        return final;
     }
-    async setStatus(collection, id, status) {
-        return this.patch(collection, id, { status });
+    async setStatus(collection, id, locale, status) {
+        let record = await this.must(collection, id);
+        let row = entryLocaleRow(record, locale);
+        if (status === "published") {
+            if (this.schema(collection).versions && !row.draftVersionId) {
+                await this.recordVersion(record, locale);
+                record = await this.must(collection, id);
+                row = entryLocaleRow(record, locale);
+            }
+            await this.updateLocale(id, locale, { status, published_version_id: row.draftVersionId });
+        }
+        else {
+            // Unpublish keeps the pointer for a later republish (spec §2).
+            await this.updateLocale(id, locale, { status });
+        }
+        await this.updateNode(id, {});
+        const final = await this.must(collection, id);
+        await this.writeRefs(final);
+        return final;
+    }
+    async addLocale(collection, id, locale, options) {
+        assertSupportedLocale(locale, this.locales);
+        const entry = await this.must(collection, id);
+        // The source is read FIRST (the memory adapter's order): "copy from a
+        // locale that isn't there" is the more specific complaint, even when
+        // the target locale already exists.
+        const source = entryLocaleRow(entry, options.from);
+        if (entry.locales[locale])
+            throw entryErrors.alreadyInLocale(id, locale);
+        const parent = entry.parentId === null ? null : await this.fetch(collection, entry.parentId);
+        this.assertParentHasLocale(parent, locale);
+        await this.assertSiblingSlug(collection, entry.parentId, locale, source.slug, id);
+        await this.insertLocale(id, locale, { slug: source.slug, fields: source.fields });
+        let added;
+        try {
+            added = await this.must(collection, id);
+            await this.recordVersion(added, locale);
+            added = await this.must(collection, id);
+            await this.writePaths(added);
+        }
+        catch (e) {
+            await this.deleteLocale(id, locale);
+            throw e;
+        }
+        await this.writeRefs(added);
+        return added;
+    }
+    async removeLocale(collection, id, locale) {
+        const schema = this.schema(collection);
+        const entry = await this.must(collection, id);
+        entryLocaleRow(entry, locale);
+        if (Object.keys(entry.locales).length === 1)
+            throw entryErrors.lastLocale(id);
+        const children = await this.db.from("entries").select(SELECT).eq("parent_id", id);
+        if (children.error)
+            this.fail(children.error.message);
+        const blockers = children.data.map(toRecord).filter((c) => c.locales[locale] !== undefined).map((c) => entryTitleIn(c, locale, schema));
+        if (blockers.length > 0)
+            throw entryErrors.localeInUse(locale, blockers);
+        // Not atomic across the two statements: a failure between them leaves
+        // a present node without that locale's path row — a 404 for that
+        // locale until the next write, never leaked content.
+        await this.deleteLocale(id, locale);
+        const remaining = await this.must(collection, id);
+        await this.writePaths(remaining);
+        await this.updateNode(id, {});
+        const final = await this.must(collection, id);
+        await this.writeRefs(final);
+        return final;
+    }
+    async listVersions(collection, id, locale) {
+        await this.must(collection, id);
+        const res = await this.db
+            .from("entry_versions")
+            .select("*")
+            .eq("entry_id", id)
+            .eq("locale", locale)
+            .order("created_at", { ascending: false })
+            .order("id", { ascending: false });
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toVersion);
     }
     async move(collection, id, to) {
-        const entry = await this.get(collection, id);
-        if (!entry)
-            throw entryErrors.notFound(collection, id);
+        const entry = await this.must(collection, id);
         const subtree = await this.subtree(entry);
         if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
             throw entryErrors.cycle();
         const byId = this.byIdMap(subtree);
-        // chainOf walks all the way to a null parentId, but `entry`'s own
-        // parentId still points OUTSIDE this subtree map (its pre-move
-        // parent) — so it can't be used here directly (page store's `move`
-        // hits the same shape and solves it the same way): stop at `entry`
-        // itself instead, since that's the map's root for this computation.
+        // `entry`'s own parentId points OUTSIDE this map (its pre-move parent):
+        // stop at `entry` itself, the map's root for this computation.
         const heightOf = (e) => (e.id === entry.id ? 1 : 1 + heightOf(byId(e.parentId)));
         const height = Math.max(...subtree.map(heightOf));
-        await this.assertParent(collection, to.parentId, height);
-        const siblings = (await this.list(collection, { parent: to.parentId, order: "manual" })).filter((s) => s.id !== id);
-        // Mirror of the memory adapter's pre-check. The index below would
-        // catch it on the parent_id update anyway, but raising here keeps the
-        // error identical across adapters and leaves the destination
-        // siblings' sorts untouched.
+        const parent = await this.assertParent(collection, to.parentId, height);
+        if (parent)
+            for (const locale of Object.keys(entry.locales))
+                if (!parent.locales[locale])
+                    throw entryErrors.moveLocales(locale);
+        const siblings = await this.siblings(collection, to.parentId, id);
         if (to.parentId !== entry.parentId) {
-            const slug = slugOf(entry.fields);
-            if (slug !== null && siblings.some((s) => slugOf(s.fields) === slug)) {
-                throw entryErrors.slugTaken(collection);
+            for (const [locale, row] of Object.entries(entry.locales)) {
+                if (row.slug !== null && siblings.some((s) => s.locales[locale]?.slug === row.slug))
+                    throw entryErrors.slugTaken(collection);
             }
         }
-        // The destination siblings' sorts as they stood BEFORE the reorder.
-        // A rollback restores these exact values rather than re-running the
-        // reorder RPC, which renumbers 1..N and would silently close gaps
-        // left by earlier deletes and moves.
+        // The destination siblings' sorts as they stood BEFORE the reorder: a
+        // rollback restores these exact values rather than renumbering 1..N.
         const previousSorts = siblings.map((s) => ({ id: s.id, sort: s.sort }));
-        const moved = await this.patch(collection, id, { parent_id: to.parentId }, { touch: false });
-        const ordered = siblings.map((s) => s.id);
-        ordered.splice(Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length), 0, id);
-        await this.reorder(collection, ordered);
         try {
-            await this.writePaths(moved);
+            await this.updateNode(id, { parent_id: to.parentId }, { touch: false });
+            const ordered = siblings.map((s) => s.id);
+            ordered.splice(Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length), 0, id);
+            await this.reorder(collection, ordered);
+            await this.writePaths(await this.must(collection, id));
         }
         catch (e) {
-            await this.patch(collection, id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
+            await this.updateNode(id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
             for (const s of previousSorts)
-                await this.patch(collection, s.id, { sort: s.sort }, { touch: false });
+                await this.updateNode(s.id, { sort: s.sort }, { touch: false });
             throw e;
         }
-        return (await this.get(collection, id));
+        return this.must(collection, id);
     }
     async delete(collection, id) {
         if (!UUID_RE.test(id))
             return;
-        const entry = await this.get(collection, id);
+        const entry = await this.fetch(collection, id);
         if (!entry)
             return;
         const children = await this.db.from("entries").select("id").eq("parent_id", id).limit(1);
@@ -317,6 +486,7 @@ export class SupabaseEntryStore {
         const refs = await this.db.from("refs").delete().eq("source_kind", "entry").eq("source_id", id);
         if (refs.error)
             this.fail(refs.error.message);
+        // locale rows and versions cascade from the node
         const res = await this.db.from("entries").delete().eq("collection", collection).eq("id", id);
         if (res.error)
             this.fail(res.error.message);
@@ -325,22 +495,16 @@ export class SupabaseEntryStore {
         return this.paths.resolve(locale, path);
     }
     async pathsOf(collection, id) {
-        return (await this.get(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
+        return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
     }
     async reorder(collection, orderedIds) {
-        schemaOf(this.collections, collection);
-        const res = await this.db.rpc("smoodly_reorder", {
-            p_collection: collection,
-            p_ids: orderedIds,
-        });
+        this.schema(collection);
+        const res = await this.db.rpc("smoodly_reorder", { p_collection: collection, p_ids: orderedIds });
         if (res.error)
             this.fail(res.error.message);
     }
     async incoming(targetId) {
-        const res = await this.db
-            .from("refs")
-            .select("source_kind, source_id")
-            .eq("target_id", targetId);
+        const res = await this.db.from("refs").select("source_kind, source_id").eq("target_id", targetId);
         if (res.error)
             this.fail(res.error.message);
         const seen = new Set(); // one row per source (multiple fields collapse)