smoodly 0.0.50 → 0.0.52

package/dist/supabase-entry-store.js

@@ -1,824 +0,0 @@
-// 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 { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, keepLocalizedShared, schemaOf, splitFields, } from "./entry-store.js";
-import { globalEntryId } from "./global-id.js";
-import { readCurrentSpace } from "./current-space.js";
-import { SupabasePathIndex } from "./supabase-path-index.js";
-import { anchorsFor } from "./anchors.js";
-import { groupRedirects } from "./store.js";
-import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
-import { assertDepth, assertSupportedLocale, entryPathRows, rewriteTargets, slugOf } 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.
-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(*, draft:entry_versions!entry_locales_draft_version_fkey(saved_at))";
-function toLocale(row) {
-    return {
-        slug: row.slug,
-        status: row.status,
-        fields: row.fields,
-        draftVersionId: row.draft_version_id,
-        draftSavedAt: row.draft?.saved_at ?? null,
-        publishedVersionId: row.published_version_id,
-        updatedAt: Date.parse(row.updated_at),
-        updatedBy: row.updated_by,
-    };
-}
-function toRecord(row) {
-    return {
-        id: row.id,
-        collection: row.collection,
-        parentId: row.parent_id,
-        fields: row.fields,
-        locales: Object.fromEntries((row.entry_locales ?? []).map((l) => [l.locale, toLocale(l)])),
-        sort: row.sort,
-        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, savedAt: Date.parse(row.saved_at) };
-}
-/** Rows per request when `list` reads a whole collection: under PostgREST's default cap. */
-const LIST_PAGE = 1000;
-export class SupabaseEntryStore {
-    constructor(db, collections, options = {}) {
-        this.db = db;
-        this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
-        this.schemas = [...collections, ...(options.globals ?? [])];
-        // Alone, the store's own index reads its collections' addresses (spec 2026-09-29 anchored paths §2).
-        this.paths = options.paths ?? new SupabasePathIndex(db, anchorsFor({ locales: this.locales, collections }));
-        this.elements = options.elements;
-    }
-    fail(message) {
-        throw new Error(`smoodly: ${message}`);
-    }
-    schema(collection) {
-        return schemaOf(this.schemas, collection);
-    }
-    /** The space this client acts in — the ONE function the policies and
-     *  the insert trigger read (src/sql-space.ts): a key's claim in the
-     *  cloud, the default space under the service role. Constant for the
-     *  life of the client, so the PROMISE is cached and concurrent creates
-     *  share one round trip; a failed lookup is not cached. */
-    space() {
-        if (!this.spaceId) {
-            this.spaceId = readCurrentSpace(this.db).catch((e) => {
-                // A failed lookup is not cached: the next write retries it.
-                this.spaceId = undefined;
-                throw e;
-            });
-        }
-        return this.spaceId;
-    }
-    // ── reads ──
-    async fetch(collection, id) {
-        if (!UUID_RE.test(id))
-            return null;
-        // Locale rows ordered by locale, as in `list`: the embed otherwise arrives in
-        // physical row order, which shifts with every update to the table.
-        const res = await this.db
-            .from("entries")
-            .select(SELECT)
-            .eq("collection", collection)
-            .eq("id", id)
-            .order("locale", { referencedTable: "entry_locales", ascending: true })
-            .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]));
-        return (id) => map.get(id);
-    }
-    async chain(entry) {
-        const chain = [entry];
-        let current = entry;
-        while (current.parentId !== null) {
-            const parent = await this.fetch(current.collection, current.parentId);
-            if (!parent)
-                this.fail(`broken parent chain at "${entry.id}".`);
-            chain.unshift(parent);
-            current = parent;
-        }
-        return chain;
-    }
-    async subtree(entry) {
-        const out = [entry];
-        let frontier = [entry.id];
-        while (frontier.length > 0) {
-            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);
-            out.push(...rows);
-            frontier = rows.map((r) => r.id);
-        }
-        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, redirect = true) {
-        const schema = this.schema(top.collection);
-        const ancestors = await this.chain(top);
-        const nodes = await this.subtree(top);
-        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema.name));
-    }
-    /** 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, this.elements)) {
-            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 null;
-        if (!UUID_RE.test(parentId))
-            throw entryErrors.notFound(collection, parentId);
-        const res = await this.db.from("entries").select(SELECT).eq("id", parentId).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        if (!res.data)
-            throw entryErrors.notFound(collection, parentId);
-        const parent = toRecord(res.data);
-        if (parent.collection !== collection)
-            throw entryErrors.foreignParent();
-        assertDepth((await this.chain(parent)).length + subtreeHeight, collectionDepth(this.schema(collection)), "the entry");
-        return parent;
-    }
-    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, by) {
-        const res = await this.db
-            .from("entry_locales")
-            .insert({ entry_id: entryId, locale, slug: row.slug, fields: row.fields, updated_by: by ?? null });
-        if (res.error) {
-            if (res.error.code === UNIQUE_VIOLATION)
-                throw entryErrors.alreadyInLocale(entryId, locale);
-            this.fail(res.error.message);
-        }
-    }
-    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
-    async updateLocale(entryId, 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("entry_locales").update(payload).eq("entry_id", entryId).eq("locale", locale);
-        if (res.error)
-            this.fail(res.error.message);
-    }
-    /** The row's stale error, built from a fresh read: what a reload would get, and who wrote last. */
-    async stale(collection, id, locale) {
-        const row = entryLocaleRow(await this.must(collection, 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(entryId, locale, patch, options) {
-        const payload = (options.touch ?? true)
-            ? { ...patch, updated_at: new Date().toISOString(), updated_by: options.by ?? null }
-            : { ...patch };
-        let query = this.db.from("entry_locales").update(payload).eq("entry_id", entryId).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("entry_id").maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data !== null;
-    }
-    /** 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);
-    }
-    /** The draft rule for every collection (spec 2026-09-14 §1), see MemoryEntryStore.recordVersion —
-     *  guarded (spec 2026-09-26 concurrency §3) when the caller verified `row` against the token:
-     *  the rewrite filters on saved_at, the first draft on the pointer. Returns the version row it
-     *  created, or null when it rewrote in place, so a failed later step can undo it. */
-    async recordVersion(entry, locale, guarded) {
-        const row = entry.locales[locale];
-        const fields = entryFieldsIn(entry, locale);
-        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
-            let query = this.db.from("entry_versions").update({ fields, saved_at: new Date().toISOString() }).eq("id", row.draftVersionId);
-            if (guarded)
-                query = query.eq("saved_at", row.draftSavedAt ?? "");
-            const res = await query.select("id").maybeSingle();
-            if (res.error)
-                this.fail(res.error.message);
-            if (res.data === null)
-                throw await this.stale(entry.collection, entry.id, locale);
-            return { created: null };
-        }
-        const res = await this.db.from("entry_versions").insert({ entry_id: entry.id, locale, fields }).select("id").single();
-        if (res.error)
-            this.fail(res.error.message);
-        const id = res.data.id;
-        let matched;
-        if (guarded)
-            matched = await this.guardedUpdateLocale(entry.id, locale, { draft_version_id: id }, { guard: row.draftVersionId, touch: false });
-        else {
-            await this.updateLocale(entry.id, locale, { draft_version_id: id }, { touch: false });
-            matched = true;
-        }
-        if (!matched) {
-            // The other writer took the pointer first: this row must never show in history.
-            const gone = await this.db.from("entry_versions").delete().eq("id", id);
-            if (gone.error)
-                this.fail(gone.error.message);
-            throw await this.stale(entry.collection, entry.id, locale);
-        }
-        return { created: id };
-    }
-    /** See MemoryEntryStore.ensureLiveSnapshot: the snapshot of what is live, both pointers on it. */
-    async ensureLiveSnapshot(entry, locale) {
-        const row = entry.locales[locale];
-        if (row.status !== "published" || row.publishedVersionId !== null)
-            return;
-        const res = await this.db.from("entry_versions").insert({ entry_id: entry.id, locale, fields: entryFieldsIn(entry, locale) }).select("id").single();
-        if (res.error)
-            this.fail(res.error.message);
-        const id = res.data.id;
-        await this.updateLocale(entry.id, locale, { draft_version_id: id, published_version_id: id }, { touch: false });
-        row.draftVersionId = id;
-        row.publishedVersionId = id;
-    }
-    // ── the contract ──
-    async create(collection, fields, options, by) {
-        const schema = this.schema(collection);
-        assertSupportedLocale(options.locale, this.locales);
-        const parentId = options.parentId ?? null;
-        if (isGlobalSchema(schema)) {
-            const existing = await this.db.from("entries").select("id").eq("collection", collection).limit(1);
-            if (existing.error)
-                this.fail(existing.error.message);
-            if (existing.data.length > 0)
-                throw entryErrors.singleton(collection);
-            if (slugOf(fields) !== null)
-                throw entryErrors.noSlug(collection);
-        }
-        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);
-        // A global item's row id is DERIVED from (space, name), not generated
-        // (spec 2026-09-07 §10): the SELECT above is a fast path two racing
-        // materializations can both pass, so the primary key is the backstop
-        // — a duplicate would be unremovable, since `delete` refuses every
-        // global row.
-        const row = { collection, parent_id: parentId, fields: shared };
-        if (isGlobalSchema(schema))
-            row.id = await globalEntryId(await this.space(), collection);
-        const inserted = await this.db.from("entries").insert(row).select("id").single();
-        if (inserted.error) {
-            if (isGlobalSchema(schema) && inserted.error.code === UNIQUE_VIOLATION)
-                throw entryErrors.singleton(collection);
-            this.fail(inserted.error.message);
-        }
-        const id = inserted.data.id;
-        try {
-            await this.insertLocale(id, options.locale, { slug, fields: localized }, by);
-            let record = await this.must(collection, id);
-            await this.recordVersion(record, options.locale, false);
-            record = await this.must(collection, id);
-            await this.writePaths(record);
-            await this.writeRefs(record);
-            return record;
-        }
-        catch (e) {
-            // 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;
-        }
-    }
-    async get(collection, id) {
-        return this.fetch(collection, id);
-    }
-    async list(collection, options) {
-        const schema = this.schema(collection);
-        // A second, aliased embed of entry_locales carries the locale gate as an
-        // inner join — presence in the locale, and its status when asked — so
-        // `limit` counts rows that are really there; the first embed still returns
-        // EVERY locale row of each record (spec 2026-09-11 §3), ordered by locale
-        // so a record's key order never depends on physical row order.
-        const gate = options?.status !== undefined || options?.locale !== undefined;
-        // Built per request: without a `limit` the list is read in pages, because
-        // PostgREST caps one response (1000 rows by default) without saying so.
-        const build = () => {
-            let query = this.db
-                .from("entries")
-                .select(gate ? `${SELECT}, gate:entry_locales!inner(locale)` : SELECT)
-                .eq("collection", collection)
-                .order("locale", { referencedTable: "entry_locales", ascending: true });
-            if (gate) {
-                query = query.eq("gate.locale", options.locale ?? this.locales.default);
-                if (options.status !== undefined)
-                    query = query.eq("gate.status", options.status);
-            }
-            if (options?.parent !== undefined) {
-                query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
-            }
-            for (const [key, want] of Object.entries(options?.where ?? {})) {
-                // Any-of compares the text form (`->>`). A scalar is JSONB containment;
-                // an array-valued field (checkboxes, refList, list, tags) contains `[value]`,
-                // a scalar field `value` — the memory adapter's matchesWhere agrees.
-                if (Array.isArray(want)) {
-                    query = query.in(`fields->>${key}`, want.map(String));
-                }
-                else {
-                    const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
-                    query = query.contains("fields", { [key]: inArray ? [want] : want });
-                }
-            }
-            const order = options?.order ?? collectionOrder(schema);
-            if (order === "manual") {
-                // `id` last in both orders: a stable order, so no row falls between two pages.
-                query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true }).order("id", { ascending: true });
-            }
-            else {
-                // `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 });
-            }
-            return query;
-        };
-        const rows = (res) => {
-            if (res.error)
-                this.fail(res.error.message);
-            return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
-        };
-        if (typeof options?.limit === "number")
-            return rows(await build().limit(options.limit));
-        const all = [];
-        for (let from = 0;; from += LIST_PAGE) {
-            const page = rows(await build().range(from, from + LIST_PAGE - 1));
-            all.push(...page);
-            if (page.length < LIST_PAGE)
-                return all;
-        }
-    }
-    async query(collection, q) {
-        const schema = this.schema(collection);
-        const where = {};
-        for (const [key, want] of Object.entries(q.where ?? {})) {
-            const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
-            where[key] = Array.isArray(want) ? { in: want.map(String) } : { contains: inArray ? [want] : want };
-        }
-        const order = q.order ?? collectionOrder(schema);
-        const res = await this.db.rpc("smoodly_list_entries", {
-            p_collection: collection,
-            p_locale: q.locale,
-            p_draft: q.draft,
-            p_where: where,
-            p_order: order === "manual" ? { by: "manual" } : order,
-            p_limit: q.limit ?? null,
-            p_parent: q.parent ?? null,
-            p_has_parent: q.parent !== undefined,
-            p_ids: q.ids ? q.ids.filter((id) => UUID_RE.test(id)) : null,
-        });
-        if (res.error)
-            this.fail(res.error.message);
-        const shown = res.data;
-        if (shown.length === 0)
-            return [];
-        // In chunks: one in() over hundreds of ids would overflow the request URL.
-        const byId = new Map();
-        for (let i = 0; i < shown.length; i += 100) {
-            const recs = await this.db.from("entries").select(SELECT).in("id", shown.slice(i, i + 100).map((r) => r.id));
-            if (recs.error)
-                this.fail(recs.error.message);
-            for (const r of recs.data)
-                byId.set(r.id, toRecord(r));
-        }
-        return shown.flatMap((r) => (byId.has(r.id) ? [{ record: byId.get(r.id), fields: r.fields }] : []));
-    }
-    async getMany(collection, ids, locale, options) {
-        this.schema(collection);
-        const uuidIds = ids.filter((id) => UUID_RE.test(id));
-        if (uuidIds.length === 0)
-            return {};
-        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 = {};
-        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;
-    }
-    async update(collection, id, locale, fields, by, expected, options) {
-        const schema = this.schema(collection);
-        const before = await this.must(collection, id);
-        const row = entryLocaleRow(before, locale);
-        assertFresh(row, expected);
-        await this.ensureLiveSnapshot(before, locale); // mutates `row`'s pointers for a legacy row
-        const { shared, localized, slug } = splitFields(fields, schema);
-        if (isGlobalSchema(schema) && slug !== null)
-            throw entryErrors.noSlug(collection);
-        await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
-        const nodeFields = keepLocalizedShared(before.fields, shared, schema);
-        // The snapshot of what the row is about to hold, written under the guard BEFORE the live
-        // columns change (spec 2026-09-26 concurrency §3): a stale save leaves nothing behind.
-        const next = { ...before, fields: nodeFields, locales: { ...before.locales, [locale]: { ...row, fields: localized, slug } } };
-        const { created } = await this.recordVersion(next, locale, expected !== undefined);
-        await this.updateNode(id, { fields: nodeFields });
-        await this.updateLocale(id, locale, { slug, fields: localized }, { by });
-        const record = await this.must(collection, id);
-        try {
-            await this.writePaths(record, options?.redirect ?? true);
-        }
-        catch (e) {
-            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(), updated_by: row.updatedBy, ...(created ? { draft_version_id: row.draftVersionId } : {}) }, { touch: false });
-            if (created)
-                await this.db.from("entry_versions").delete().eq("id", created);
-            else {
-                // The in-place rewrite moved saved_at too: put the token back as it was read.
-                const undo = { fields: entryFieldsIn(before, locale), ...(row.draftSavedAt ? { saved_at: row.draftSavedAt } : {}) };
-                await this.db.from("entry_versions").update(undo).eq("id", row.draftVersionId);
-            }
-            throw e;
-        }
-        const final = await this.must(collection, id);
-        await this.writeRefs(final);
-        return final;
-    }
-    async setStatus(collection, id, locale, status, by, expected) {
-        let record = await this.must(collection, id);
-        let row = entryLocaleRow(record, locale);
-        if (status === "published") {
-            assertFresh(row, expected);
-            if (!row.draftVersionId) {
-                await this.recordVersion(record, locale, false);
-                record = await this.must(collection, id);
-                row = entryLocaleRow(record, locale);
-            }
-            const matched = await this.guardedUpdateLocale(id, locale, { status, published_version_id: row.draftVersionId }, { by, guard: expected !== undefined ? row.draftVersionId : undefined });
-            if (!matched)
-                throw await this.stale(collection, id, locale);
-        }
-        else {
-            // Unpublish keeps the pointer for a later republish (spec §2) and is not guarded.
-            await this.updateLocale(id, locale, { status }, { by });
-        }
-        await this.updateNode(id, {});
-        const final = await this.must(collection, id);
-        await this.writeRefs(final);
-        return final;
-    }
-    async discardDraft(collection, id, locale, by, expected) {
-        const schema = this.schema(collection);
-        const record = await this.must(collection, id);
-        const row = entryLocaleRow(record, locale);
-        assertFresh(row, expected);
-        const snapshot = row.publishedVersionId ? (await this.versionFields([row.publishedVersionId])).get(row.publishedVersionId) : undefined;
-        if (!snapshot)
-            throw entryErrors.nothingPublished(collection, id, locale);
-        const { shared, localized } = splitFields(snapshot, schema);
-        // The pointer moves under the guard before the fields (spec 2026-09-26 concurrency §3).
-        const matched = await this.guardedUpdateLocale(id, locale, { fields: localized, draft_version_id: row.publishedVersionId }, { by, guard: expected !== undefined ? row.draftVersionId : undefined });
-        if (!matched)
-            throw await this.stale(collection, id, locale);
-        await this.updateNode(id, { fields: keepLocalizedShared(record.fields, shared, schema) });
-        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("entry_versions").delete().eq("id", row.draftVersionId);
-            if (gone.error)
-                this.fail(gone.error.message);
-        }
-        const final = await this.must(collection, id);
-        await this.writeRefs(final);
-        return final;
-    }
-    async addLocale(collection, id, locale, options, by) {
-        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 }, by);
-        let added;
-        try {
-            added = await this.must(collection, id);
-            await this.recordVersion(added, locale, false);
-            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);
-        if (isGlobalSchema(schema))
-            throw entryErrors.everyLocale(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, false);
-        await this.updateNode(id, {});
-        const final = await this.must(collection, id);
-        await this.writeRefs(final);
-        return final;
-    }
-    async scanEntries() {
-        const res = await this.db.from("entries").select(SELECT).order("created_at", { ascending: true }).order("id", { ascending: true });
-        if (res.error)
-            this.fail(res.error.message);
-        const records = res.data.map(toRecord);
-        const ids = records.flatMap((r) => Object.values(r.locales).flatMap((row) => (row.status === "published" && row.publishedVersionId ? [row.publishedVersionId] : [])));
-        // In chunks: one in() over hundreds of ids would overflow the request URL.
-        const snaps = new Map();
-        for (let i = 0; i < ids.length; i += 100) {
-            for (const [id, fields] of await this.versionFields(ids.slice(i, i + 100)))
-                snaps.set(id, fields);
-        }
-        return records.map((record) => ({
-            record,
-            live: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [
-                l,
-                row.status !== "published" ? null : (row.publishedVersionId ? snaps.get(row.publishedVersionId) : undefined) ?? entryFieldsIn(record, l),
-            ])),
-        }));
-    }
-    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("saved_at", { ascending: false })
-            .order("id", { ascending: false });
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(toVersion);
-    }
-    async restore(collection, id, locale, versionId, by, expected) {
-        const schema = this.schema(collection);
-        const entry = await this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        const version = await this.getVersion(collection, versionId);
-        if (!version || version.entryId !== id || version.locale !== locale)
-            throw entryErrors.foreignVersion(collection, id, locale, versionId);
-        assertFresh(row, expected);
-        if (versionId === row.publishedVersionId)
-            return this.discardDraft(collection, id, locale, by, expected);
-        const { shared: split, localized } = splitFields(version.fields, schema);
-        const shared = keepLocalizedShared(entry.fields, split, schema);
-        // The snapshot first, under the guard, as in update.
-        const next = { ...entry, fields: shared, locales: { ...entry.locales, [locale]: { ...row, fields: localized } } };
-        await this.recordVersion(next, locale, expected !== undefined);
-        await this.updateNode(id, { fields: shared });
-        await this.updateLocale(id, locale, { fields: localized }, { by }); // the slug is the row's own and never versioned
-        const final = await this.must(collection, id);
-        await this.writeRefs(final);
-        return final;
-    }
-    async getVersion(collection, versionId) {
-        this.schema(collection);
-        if (!UUID_RE.test(versionId))
-            return null;
-        const res = await this.db.from("entry_versions").select("*").eq("id", versionId).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? toVersion(res.data) : null;
-    }
-    async move(collection, id, to, options) {
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "it has no tree position");
-        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);
-        // `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));
-        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) {
-            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 renumbering 1..N.
-        const previousSorts = siblings.map((s) => ({ id: s.id, sort: s.sort }));
-        try {
-            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), options?.redirect ?? true);
-        }
-        catch (e) {
-            await this.updateNode(id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
-            for (const s of previousSorts)
-                await this.updateNode(s.id, { sort: s.sort }, { touch: false });
-            throw e;
-        }
-        return this.must(collection, id);
-    }
-    async delete(collection, id) {
-        if (!UUID_RE.test(id))
-            return;
-        const entry = await this.fetch(collection, id);
-        if (!entry)
-            return;
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "remove the registration to remove it");
-        const children = await this.db.from("entries").select("id").eq("parent_id", id).limit(1);
-        if (children.error)
-            this.fail(children.error.message);
-        if (children.data.length > 0)
-            throw entryErrors.hasChildren(collection, id);
-        const usage = await this.referencesTo(collection, id);
-        if (usage.length > 0) {
-            this.fail(`"${collection}/${id}" is referenced by ${usage.length} document(s) — remove those references first.`);
-        }
-        await this.paths.remove([{ kind: "entry", id }]);
-        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);
-    }
-    resolvePath(locale, path) {
-        return this.paths.resolve(locale, path);
-    }
-    pathsIn(collection, ids, locale) {
-        this.schema(collection);
-        return this.paths.livePathsIn("entry", ids, locale);
-    }
-    async pathsOf(collection, id) {
-        return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
-    }
-    async redirectsOf(collection, id) {
-        return (await this.fetch(collection, id)) ? groupRedirects(await this.paths.redirectsOf({ kind: "entry", id })) : {};
-    }
-    async reorder(collection, orderedIds) {
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "it has no order");
-        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);
-        if (res.error)
-            this.fail(res.error.message);
-        const seen = new Set(); // one row per source (multiple fields collapse)
-        const out = [];
-        for (const r of res.data) {
-            const key = `${r.source_kind} ${r.source_id}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            out.push({ sourceKind: r.source_kind, sourceId: r.source_id });
-        }
-        return out;
-    }
-    async referencesTo(collection, id) {
-        const res = await this.db
-            .from("refs")
-            .select("source_kind, source_id, source_field")
-            .eq("target_collection", collection)
-            .eq("target_id", id);
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map((r) => ({ sourceKind: r.source_kind, sourceId: r.source_id, sourceField: r.source_field }));
-    }
-}