smoodly 0.0.51 → 0.0.52

package/dist/supabase-store.js

@@ -1,678 +0,0 @@
-// The Supabase adapter for the PageStore contract, over pages +
-// page_locales + page_versions + paths. Server-side only (the service
-// role in self-host, a write key in the cloud); writes flow through
-// Smoodly's API by design (DESIGN.md §1). No FK links the locale rows'
-// version pointers to page_versions (they'd be circular), so tree reads
-// are two indexed lookups. Every read embeds the locale rows
-// (`*, page_locales(*)`) so a record arrives whole. Path rows are
-// rewritten through ONE RPC per write, so a collision rolls back.
-import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, storeAnchors, } from "./store.js";
-import { SupabasePathIndex } from "./supabase-path-index.js";
-import { secretKeyRefusedMessage } from "./schema-version.js";
-import { readSchemaVersion, SecretKeyCheck } from "./schema-read.js";
-import { groupRedirects } from "./store.js";
-import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
-import { assertDepth, assertSegment, isHomeNode, pagePathRows, rewriteTargets } from "./paths.js";
-const SELECT = "*, page_locales(*, draft:page_versions!page_locales_draft_version_fkey(saved_at))";
-const UNIQUE_VIOLATION = "23505";
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function toRecord(row) {
-    const locales = {};
-    for (const l of row.page_locales ?? []) {
-        locales[l.locale] = {
-            slug: l.slug,
-            title: l.title,
-            status: l.status,
-            draftVersionId: l.draft_version_id,
-            draftSavedAt: l.draft?.saved_at ?? null,
-            publishedVersionId: l.published_version_id,
-            updatedAt: Date.parse(l.updated_at),
-            updatedBy: l.updated_by,
-        };
-    }
-    return {
-        id: row.id,
-        parentId: row.parent_id,
-        template: row.template,
-        fixed: row.fixed ?? null,
-        sort: row.sort === null ? null : Number(row.sort),
-        locales,
-    };
-}
-function toVersion(row) {
-    return { id: row.id, pageId: row.page_id, locale: row.locale, tree: row.tree, savedAt: Date.parse(row.saved_at) };
-}
-export class SupabasePageStore {
-    constructor(db, options = {}) {
-        this.db = db;
-        this.options = options;
-        /** Once per store; a refused key fails lookups for 30 s at a time (schema-read.ts). */
-        this.keyCheck = new SecretKeyCheck(() => readSchemaVersion(this.db));
-        this.options = { ...options, sections: refSections(options) };
-        this.opts = pathOptions(options);
-        // Alone, the store's own index reads the addresses it was given (spec 2026-09-29 anchored paths §2).
-        this.paths = options.paths ?? new SupabasePathIndex(db, storeAnchors(options));
-    }
-    fail(message) {
-        throw new Error(`smoodly: ${message}`);
-    }
-    isHome(page) {
-        return isHomeNode(page, this.opts);
-    }
-    // ── rows ──
-    async row(id) {
-        if (!UUID_RE.test(id))
-            return null;
-        const res = await this.db.from("pages").select(SELECT).eq("id", id).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? toRecord(res.data) : null;
-    }
-    async must(id) {
-        const page = await this.row(id);
-        if (!page)
-            throw pageErrors.notFound(id);
-        return page;
-    }
-    /** A one-row existence check — the shape `deletePage` needs too. */
-    async hasChildren(id) {
-        const res = await this.db.from("pages").select("id").eq("parent_id", id).limit(1);
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.length > 0;
-    }
-    async siblings(parentId, except) {
-        let query = this.db.from("pages").select(SELECT);
-        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 })
-            .order("id", { ascending: true });
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(toRecord).filter((p) => p.id !== except);
-    }
-    /** Code-owned roots are left out: their path is their address, and the
-     *  path index guards it (spec 2026-09-29 nested paths §3). */
-    async assertSlugFree(parentId, locale, slug, except) {
-        if ((await this.siblings(parentId, except)).some((s) => !s.fixed && s.locales[locale]?.slug === slug))
-            throw pageErrors.slugTaken(slug);
-    }
-    /** The node's ancestors (root first, node last), by walking parent_id. */
-    async chain(page) {
-        const chain = [page];
-        let current = page;
-        while (current.parentId !== null) {
-            const parent = await this.row(current.parentId);
-            if (!parent)
-                this.fail(`broken parent chain at "${page.id}".`);
-            chain.unshift(parent);
-            current = parent;
-        }
-        return chain;
-    }
-    /** The node and every descendant, breadth-first. */
-    async subtree(page) {
-        const out = [page];
-        let frontier = [page.id];
-        while (frontier.length > 0) {
-            const res = await this.db.from("pages").select(SELECT).in("parent_id", frontier);
-            if (res.error)
-                this.fail(res.error.message);
-            const rows = res.data.map(toRecord);
-            out.push(...rows);
-            frontier = rows.map((r) => r.id);
-        }
-        return out;
-    }
-    /** Rewrite path rows for a subtree: ancestors are loaded once so the
-     *  chain lookup is a map, then ONE RPC replaces every target's rows. */
-    async writePaths(top, redirect = true) {
-        const ancestors = await this.chain(top);
-        const nodes = await this.subtree(top);
-        const byId = new Map([...ancestors, ...nodes].map((n) => [n.id, n]));
-        await this.paths.rewrite(rewriteTargets("page", nodes, redirect), pagePathRows(nodes, (id) => byId.get(id), this.opts));
-    }
-    /** `touch` defaults to true (the normal edit path bumps updated_at).
-     *  A rollback restoring prior column values passes `{ touch: false }`,
-     *  which omits updated_at entirely — undoing a write is not an edit. */
-    async updateNode(id, patch, options = {}) {
-        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
-        const res = await this.db.from("pages").update(payload).eq("id", id).select(SELECT).single();
-        if (res.error)
-            this.fail(res.error.message);
-        return toRecord(res.data);
-    }
-    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
-    async updateLocale(id, locale, patch, options = {}) {
-        const payload = (options.touch ?? true)
-            ? { ...patch, updated_at: new Date().toISOString(), updated_by: options.by ?? null }
-            : { ...patch };
-        const res = await this.db.from("page_locales").update(payload).eq("page_id", id).eq("locale", locale).select("page_id").single();
-        if (res.error)
-            this.fail(res.error.message);
-        return this.must(id);
-    }
-    /** The row's stale error, built from a fresh read: what a reload would get, and who wrote last. */
-    async stale(id, locale) {
-        const row = localeRow(await this.must(id), locale);
-        return new StaleDraftError(draftToken(row), row.updatedBy, row.updatedAt);
-    }
-    /** `updateLocale` with the pointer as a filter (spec 2026-09-26 concurrency §3): the row is
-     *  written only while `draft_version_id` still equals `guard` (null = still no pointer).
-     *  `undefined` guard = unconditional. Resolves false when no row matched. */
-    async guardedUpdateLocale(id, locale, patch, options) {
-        const payload = { ...patch, updated_at: new Date().toISOString(), updated_by: options.by ?? null };
-        let query = this.db.from("page_locales").update(payload).eq("page_id", id).eq("locale", locale);
-        if (options.guard !== undefined)
-            query = options.guard === null ? query.is("draft_version_id", null) : query.eq("draft_version_id", options.guard);
-        const res = await query.select("page_id").maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data !== null;
-    }
-    async insertLocale(id, locale, values) {
-        const res = await this.db.from("page_locales").insert({ page_id: id, locale, ...values });
-        if (res.error) {
-            if (res.error.code === UNIQUE_VIOLATION)
-                throw pageErrors.alreadyInLocale(id, locale);
-            this.fail(res.error.message);
-        }
-    }
-    /** The locale's row and versions — the removeLocale and rollback shape.
-     *  The row goes first: it is what makes the page exist in that locale,
-     *  so a failure between the two statements leaves no locale row
-     *  pointing at an already-deleted version. */
-    async deleteLocale(id, locale) {
-        const row = await this.db.from("page_locales").delete().eq("page_id", id).eq("locale", locale);
-        if (row.error)
-            this.fail(row.error.message);
-        const versions = await this.db.from("page_versions").delete().eq("page_id", id).eq("locale", locale);
-        if (versions.error)
-            this.fail(versions.error.message);
-    }
-    async insertVersion(pageId, locale, tree) {
-        const res = await this.db.from("page_versions").insert({ page_id: pageId, locale, tree }).select("*").single();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data;
-    }
-    /** The draft rule (spec 2026-09-13 history §1), see MemoryPageStore.writeDraftVersion —
-     *  and the guard (spec 2026-09-26 concurrency §3): the caller ran assertFresh on the row it
-     *  holds, so `row` IS the expected state; the write itself filters on it, closing the
-     *  read-then-write window. `guarded` false = a script, no filters. */
-    async writeDraftVersion(page, locale, tree, by, guarded) {
-        const row = localeRow(page, locale);
-        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
-            let query = this.db.from("page_versions").update({ tree, saved_at: new Date().toISOString() }).eq("id", row.draftVersionId);
-            if (guarded)
-                query = query.eq("saved_at", row.draftSavedAt ?? "");
-            const res = await query.select("*").maybeSingle();
-            if (res.error)
-                this.fail(res.error.message);
-            if (res.data === null)
-                throw await this.stale(page.id, locale);
-            const record = await this.updateLocale(page.id, locale, {}, { by });
-            return { version: res.data, record };
-        }
-        const version = await this.insertVersion(page.id, locale, tree);
-        const matched = await this.guardedUpdateLocale(page.id, locale, { draft_version_id: version.id }, { by, guard: guarded ? row.draftVersionId : undefined });
-        if (!matched) {
-            // The other writer took the pointer first: this row must never show in history.
-            const gone = await this.db.from("page_versions").delete().eq("id", version.id);
-            if (gone.error)
-                this.fail(gone.error.message);
-            throw await this.stale(page.id, locale);
-        }
-        return { version, record: await this.must(page.id) };
-    }
-    async versionTree(versionId) {
-        if (!versionId)
-            return null;
-        const res = await this.db.from("page_versions").select("tree").eq("id", versionId).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data?.tree ?? null;
-    }
-    /** Every locale's draft and published trees in ONE query. */
-    async liveTrees(page) {
-        const ids = new Set();
-        for (const row of Object.values(page.locales)) {
-            if (row.draftVersionId)
-                ids.add(row.draftVersionId);
-            if (row.publishedVersionId)
-                ids.add(row.publishedVersionId);
-        }
-        if (ids.size === 0)
-            return [];
-        const res = await this.db.from("page_versions").select("tree").in("id", [...ids]);
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map((r) => r.tree);
-    }
-    async writeRefs(page) {
-        if (!this.options.sections)
-            return;
-        const edges = pageRefEdges(await this.liveTrees(page), this.options.sections, this.options.elements);
-        const deleted = await this.db.from("refs").delete().eq("source_kind", "page").eq("source_id", page.id);
-        if (deleted.error)
-            this.fail(deleted.error.message);
-        const rows = new Map();
-        for (const edge of edges) {
-            rows.set(`${edge.field} ${edge.targetId}`, {
-                source_kind: "page", source_id: page.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);
-        }
-    }
-    async reorder(ids) {
-        if (ids.length === 0)
-            return;
-        const res = await this.db.rpc("smoodly_reorder_pages", { p_ids: ids });
-        if (res.error)
-            this.fail(res.error.message);
-    }
-    /** page_locales and page_versions cascade from pages; refs do not. */
-    async hardDelete(id) {
-        const refs = await this.db.from("refs").delete().eq("source_kind", "page").eq("source_id", id);
-        if (refs.error)
-            this.fail(refs.error.message);
-        const page = await this.db.from("pages").delete().eq("id", id);
-        if (page.error)
-            this.fail(page.error.message);
-    }
-    // ── contract ──
-    async createPage(input, by) {
-        assertSupportedLocale(input.locale, this.opts.locales);
-        assertSegment(input.slug, "page slug");
-        const parentId = input.parentId ?? null;
-        if (input.fixed !== undefined) {
-            if (parentId !== null)
-                throw pageErrors.fixedAtRoot();
-            const owned = await this.db.from("pages").select("id").eq("fixed", input.fixed).limit(1);
-            if (owned.error)
-                this.fail(owned.error.message);
-            if (owned.data.length > 0)
-                throw pageErrors.fixedTaken(input.fixed);
-        }
-        if (parentId !== null) {
-            const parent = await this.must(parentId);
-            if (this.isHome(parent))
-                throw pageErrors.homeChildren();
-            if (!parent.locales[input.locale])
-                throw pageErrors.parentNotInLocale(input.locale);
-            assertDepth((await this.chain(parent)).length + 1, this.opts.depth, "the page");
-        }
-        const siblings = await this.siblings(parentId);
-        if (input.fixed === undefined && siblings.some((s) => !s.fixed && s.locales[input.locale]?.slug === input.slug)) {
-            throw pageErrors.slugTaken(input.slug);
-        }
-        const inserted = await this.db
-            .from("pages")
-            .insert({ parent_id: parentId, template: input.template, sort: siblings.length + 1, fixed: input.fixed ?? null })
-            .select("id")
-            .single();
-        if (inserted.error) {
-            // A racing materializer inserted the owner first: the unique index is the backstop.
-            if (inserted.error.code === UNIQUE_VIOLATION && input.fixed !== undefined)
-                throw pageErrors.fixedTaken(input.fixed);
-            this.fail(inserted.error.message);
-        }
-        const id = inserted.data.id;
-        try {
-            const version = input.template === null ? null : await this.insertVersion(id, input.locale, { zones: {} });
-            await this.insertLocale(id, input.locale, {
-                slug: input.slug, title: input.title ?? input.slug, draft_version_id: version?.id ?? null, updated_by: by ?? null,
-            });
-            const page = await this.must(id);
-            await this.writePaths(page);
-            return page;
-        }
-        catch (e) {
-            await this.hardDelete(id);
-            throw e;
-        }
-    }
-    getPage(id) {
-        return this.row(id);
-    }
-    async scanTrees() {
-        const records = await this.listPages();
-        const ids = new Set();
-        for (const r of records)
-            for (const row of Object.values(r.locales)) {
-                if (row.draftVersionId)
-                    ids.add(row.draftVersionId);
-                if (row.publishedVersionId)
-                    ids.add(row.publishedVersionId);
-            }
-        // In chunks: one in() over hundreds of ids would overflow the request URL.
-        const trees = new Map();
-        const all = [...ids];
-        for (let i = 0; i < all.length; i += 100) {
-            const res = await this.db.from("page_versions").select("id, tree").in("id", all.slice(i, i + 100));
-            if (res.error)
-                this.fail(res.error.message);
-            for (const v of res.data)
-                trees.set(v.id, v.tree);
-        }
-        const tree = (id) => (id ? trees.get(id) ?? null : null);
-        return records.map((record) => ({
-            record,
-            draft: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [l, tree(row.draftVersionId)])),
-            live: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [l, tree(row.publishedVersionId)])),
-        }));
-    }
-    async listPages() {
-        const res = await this.db
-            .from("pages")
-            .select(SELECT)
-            .order("sort", { ascending: true, nullsFirst: false })
-            .order("created_at", { ascending: true })
-            .order("id", { ascending: true });
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(toRecord);
-    }
-    async resolvePath(locale, path) {
-        // In parallel: the check costs the first request no extra round trip.
-        const [refused, hit] = await Promise.all([this.keyCheck.refused(), this.paths.resolve(locale, path)]);
-        if (refused)
-            throw new Error(secretKeyRefusedMessage);
-        return hit;
-    }
-    async schemaVersion() {
-        const read = await readSchemaVersion(this.db);
-        if ("version" in read)
-            return read.version;
-        // The table exists and the row is hidden: the key is not a secret key.
-        if (read.missing === "key")
-            throw new Error(secretKeyRefusedMessage);
-        return null;
-    }
-    pathsOf(id) {
-        return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});
-    }
-    targetPaths(target) { return this.paths.pathsOf(target); }
-    async redirectsOf(id) { return UUID_RE.test(id) ? groupRedirects(await this.paths.redirectsOf({ kind: "page", id })) : {}; }
-    listLive(locale) { return this.paths.listLive(locale); }
-    listRedirects(locale) { return this.paths.listRedirects(locale); }
-    addRedirect(row) { return this.paths.addRedirect(row); }
-    removeRedirect(locale, path) { return this.paths.removeRedirect(locale, path); }
-    async addLocale(id, locale, options, by) {
-        assertSupportedLocale(locale, this.opts.locales);
-        const page = await this.must(id);
-        if (page.locales[locale])
-            throw pageErrors.alreadyInLocale(id, locale);
-        const source = localeRow(page, options.from);
-        const slug = options.slug ?? source.slug;
-        if (options.slug !== undefined)
-            assertSegment(slug, `page slug (${locale})`);
-        if (page.parentId !== null && !(await this.must(page.parentId)).locales[locale])
-            throw pageErrors.parentNotInLocale(locale);
-        if (!page.fixed)
-            await this.assertSlugFree(page.parentId, locale, slug, id);
-        let added;
-        try {
-            // The SOURCE'S DRAFT is the copy (spec §3); a folder has no tree.
-            const version = page.template === null
-                ? null
-                : await this.insertVersion(id, locale, (await this.versionTree(source.draftVersionId)) ?? { zones: {} });
-            await this.insertLocale(id, locale, {
-                slug, title: options.title ?? source.title, draft_version_id: version?.id ?? null, updated_by: by ?? null,
-            });
-            added = await this.must(id);
-            await this.writePaths(added);
-        }
-        catch (e) {
-            await this.deleteLocale(id, locale);
-            throw e;
-        }
-        await this.writeRefs(added);
-        return added;
-    }
-    async removeLocale(id, locale) {
-        const page = await this.must(id);
-        localeRow(page, locale);
-        if (Object.keys(page.locales).length === 1)
-            throw pageErrors.lastLocale(id);
-        const blockers = (await this.subtree(page)).filter((n) => n.id !== id && n.locales[locale]);
-        if (blockers.length > 0)
-            throw pageErrors.localeInUse(locale, blockers.map((b) => b.locales[locale].title));
-        // Fewer path rows can never collide, so the row goes first and a
-        // network failure on the rewrite leaves a stale path row that
-        // resolves to a page absent in that locale — a 404, never leaked
-        // content — until the next write of this node fixes it.
-        await this.deleteLocale(id, locale);
-        const remaining = await this.must(id);
-        await this.writePaths(remaining, false);
-        await this.writeRefs(remaining);
-        return remaining;
-    }
-    async rename(id, patch, by, options) {
-        const page = await this.must(id);
-        const row = localeRow(page, patch.locale);
-        if (patch.slug !== undefined)
-            assertSegment(patch.slug, `page slug (${patch.locale})`);
-        // A rename that turns this node INTO the home node (root, default-locale
-        // slug === homePageSlug) is subject to the same invariant as createPage:
-        // the home page cannot have child pages.
-        if (patch.locale === this.opts.locales.default &&
-            patch.slug !== undefined &&
-            page.parentId === null &&
-            patch.slug === this.opts.homePageSlug &&
-            (await this.hasChildren(id))) {
-            throw pageErrors.homeChildren();
-        }
-        if (patch.slug !== undefined && !page.fixed)
-            await this.assertSlugFree(page.parentId, patch.locale, patch.slug, id);
-        const columns = {};
-        if (patch.slug !== undefined)
-            columns.slug = patch.slug;
-        if (patch.title !== undefined)
-            columns.title = patch.title;
-        const renamed = await this.updateLocale(id, patch.locale, columns, { by });
-        try {
-            await this.writePaths(renamed, options?.redirect ?? true);
-        }
-        catch (e) {
-            // The audit pair goes back too: a rejected rename is not an edit.
-            await this.updateLocale(id, patch.locale, { slug: row.slug, title: row.title, updated_at: new Date(row.updatedAt).toISOString(), updated_by: row.updatedBy }, { touch: false });
-            throw e;
-        }
-        return renamed;
-    }
-    async move(id, to, options) {
-        const page = await this.must(id);
-        if (page.fixed && to.parentId !== null)
-            throw pageErrors.fixedAtRoot();
-        const subtree = await this.subtree(page);
-        if (to.parentId !== null) {
-            if (to.parentId === id || subtree.some((n) => n.id === to.parentId))
-                throw pageErrors.cycle();
-            const parent = await this.must(to.parentId);
-            if (this.isHome(parent))
-                throw pageErrors.homeChildren();
-            for (const locale of Object.keys(page.locales))
-                if (!parent.locales[locale])
-                    throw pageErrors.moveLocales(locale);
-            const byId = new Map(subtree.map((n) => [n.id, n]));
-            // The subtree's own height: walk each node up to the moved node
-            // itself (not to the tree root — its parentId points OUTSIDE this
-            // subtree map, at its current, pre-move parent, so chainOf would
-            // throw "broken parent chain" there instead of stopping).
-            const heightOf = (n) => (n.id === page.id ? 1 : 1 + heightOf(byId.get(n.parentId)));
-            const height = Math.max(...subtree.map(heightOf));
-            assertDepth((await this.chain(parent)).length + height, this.opts.depth, "the page");
-        }
-        else if (page.locales[this.opts.locales.default]?.slug === this.opts.homePageSlug && (await this.hasChildren(id))) {
-            // Moving a home-slugged node TO the root is the mirror case of the
-            // rename guard above: it would make it the home node while it still
-            // has children.
-            throw pageErrors.homeChildren();
-        }
-        const siblings = await this.siblings(to.parentId, id);
-        if (to.parentId !== page.parentId) {
-            for (const [locale, row] of Object.entries(page.locales)) {
-                if (siblings.some((s) => !s.fixed && s.locales[locale]?.slug === row.slug))
-                    throw pageErrors.slugTaken(row.slug);
-            }
-        }
-        // 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.
-        const previousSorts = siblings.map((s) => ({ id: s.id, sort: s.sort }));
-        const moved = await this.updateNode(id, { parent_id: to.parentId });
-        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
-        const ordered = siblings.map((s) => s.id);
-        ordered.splice(index, 0, id);
-        try {
-            await this.reorder(ordered);
-            await this.writePaths(moved, options?.redirect ?? true);
-        }
-        catch (e) {
-            await this.updateNode(id, { parent_id: page.parentId, sort: page.sort }, { touch: false });
-            for (const s of previousSorts)
-                await this.updateNode(s.id, { sort: s.sort }, { touch: false });
-            throw e;
-        }
-        return { ...moved, sort: index + 1 };
-    }
-    async setTemplate(id, template, by) {
-        const page = await this.must(id);
-        if (page.template !== null)
-            throw pageErrors.hasTemplate(id);
-        for (const locale of Object.keys(page.locales)) {
-            const version = await this.insertVersion(id, locale, { zones: {} });
-            await this.updateLocale(id, locale, { draft_version_id: version.id }, { by });
-        }
-        return this.updateNode(id, { template });
-    }
-    async saveDraft(id, locale, tree, by, expected) {
-        const page = await this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        assertFresh(localeRow(page, locale), expected);
-        const { version, record } = await this.writeDraftVersion(page, locale, tree, by, expected !== undefined);
-        await this.writeRefs(record);
-        return toVersion(version);
-    }
-    async publish(id, locale, by, expected) {
-        const page = await this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        const row = localeRow(page, locale);
-        assertFresh(row, expected);
-        if (!row.draftVersionId)
-            throw pageErrors.folder(id);
-        const { sections, entries } = this.options;
-        const draft = (await this.versionTree(row.draftVersionId)) ?? { zones: {} };
-        if (sections && entries)
-            await assertPublishable(row.slug, draft, sections, entries, locale);
-        const matched = await this.guardedUpdateLocale(id, locale, { published_version_id: row.draftVersionId, status: "published" }, { by, guard: expected !== undefined ? row.draftVersionId : undefined });
-        if (!matched)
-            throw await this.stale(id, locale);
-        const record = await this.must(id);
-        await this.writeRefs(record);
-        return record;
-    }
-    async discardDraft(id, locale, by, expected) {
-        const page = await this.must(id);
-        const row = localeRow(page, locale);
-        assertFresh(row, expected);
-        if (!row.publishedVersionId)
-            throw pageErrors.nothingPublished(id, locale);
-        const matched = await this.guardedUpdateLocale(id, locale, { draft_version_id: row.publishedVersionId }, { by, guard: expected !== undefined ? row.draftVersionId : undefined });
-        if (!matched)
-            throw await this.stale(id, locale);
-        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
-            // The pointer moved first, so a failure here leaves a stray row, never a dangling pointer.
-            const gone = await this.db.from("page_versions").delete().eq("id", row.draftVersionId);
-            if (gone.error)
-                this.fail(gone.error.message);
-        }
-        const record = await this.must(id);
-        await this.writeRefs(record);
-        return record;
-    }
-    async unpublish(id, locale, by) {
-        const page = await this.must(id);
-        localeRow(page, locale); // the "does not exist in locale" guard
-        const record = await this.updateLocale(id, locale, { status: "draft" }, { by });
-        await this.writeRefs(record);
-        return record;
-    }
-    async restore(id, locale, versionId, by, expected) {
-        const page = await this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        const row = localeRow(page, locale);
-        const version = await this.getVersion(versionId);
-        if (!version || version.pageId !== id || version.locale !== locale)
-            throw pageErrors.foreignVersion(id, locale, versionId);
-        assertFresh(row, expected);
-        if (versionId === row.publishedVersionId)
-            return this.discardDraft(id, locale, by, expected);
-        const { record } = await this.writeDraftVersion(page, locale, version.tree, by, expected !== undefined);
-        await this.writeRefs(record);
-        return record;
-    }
-    async getVersion(versionId) {
-        if (!UUID_RE.test(versionId))
-            return null;
-        const res = await this.db.from("page_versions").select("*").eq("id", versionId).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? toVersion(res.data) : null;
-    }
-    async getDraftTree(id, locale) {
-        const page = await this.row(id);
-        return page ? this.versionTree(page.locales[locale]?.draftVersionId ?? null) : null;
-    }
-    async fieldsOf(versionIds) {
-        const ids = versionIds.filter((id) => UUID_RE.test(id));
-        if (ids.length === 0)
-            return {};
-        // PostgREST's JSON arrow selects the `fields` key alone — the rest of the tree never leaves the database.
-        const res = await this.db.from("page_versions").select("id, fields:tree->fields").in("id", ids);
-        if (res.error)
-            this.fail(res.error.message);
-        const out = {};
-        for (const row of res.data)
-            out[row.id] = row.fields ?? {};
-        return out;
-    }
-    async getPublishedTree(id, locale) {
-        const page = await this.row(id);
-        return page ? this.versionTree(page.locales[locale]?.publishedVersionId ?? null) : null;
-    }
-    async listVersions(id, locale) {
-        if (!UUID_RE.test(id))
-            return [];
-        const res = await this.db
-            .from("page_versions")
-            .select("*")
-            .eq("page_id", id)
-            .eq("locale", locale)
-            .order("saved_at", { ascending: false })
-            .order("id", { ascending: false });
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(toVersion);
-    }
-    async deletePage(id) {
-        const page = await this.row(id);
-        if (!page)
-            return;
-        if (await this.hasChildren(id))
-            throw pageErrors.hasChildren(id);
-        await this.paths.remove([{ kind: "page", id }]);
-        await this.hardDelete(id);
-    }
-}