smoodly 0.0.51 → 0.0.53

package/dist/supabase-member-store.d.ts

@@ -1,21 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import { type InviteInput, type InviteResult, type MemberRecord, type MemberStore } from "./member-store.ts";
-import type { MemberRole } from "./permissions.ts";
-export declare class SupabaseMemberStore implements MemberStore {
-    private db;
-    constructor(db: SupabaseClient);
-    list(): Promise<MemberRecord[]>;
-    consoleUrl(): Promise<string | null>;
-    private toRecord;
-    /** The admin API has no lookup by email: page through the users (tens, not thousands). */
-    private userIdByEmail;
-    invite(input: InviteInput): Promise<InviteResult>;
-    private upsertRow;
-    createAccount(input: {
-        email: string;
-        password: string;
-        role: MemberRole;
-    }): Promise<MemberRecord>;
-    setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
-    remove(userId: string): Promise<void>;
-}

package/dist/supabase-member-store.js

@@ -1,96 +0,0 @@
-import { memberErrors, sortMembers } from "./member-store.js";
-export class SupabaseMemberStore {
-    constructor(db) {
-        this.db = db;
-    }
-    async list() {
-        const res = await this.db.from("members").select("user_id, email, role");
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return sortMembers(res.data.map((r) => this.toRecord(r)));
-    }
-    async consoleUrl() {
-        const res = await this.db.from("spaces").select("console_url").limit(1).maybeSingle();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data?.console_url ?? null;
-    }
-    toRecord(row) {
-        return { userId: row.user_id, email: row.email, role: row.role };
-    }
-    /** The admin API has no lookup by email: page through the users (tens, not thousands). */
-    async userIdByEmail(email) {
-        const wanted = email.toLowerCase();
-        for (let page = 1; page <= 50; page++) {
-            const res = await this.db.auth.admin.listUsers({ page, perPage: 200 });
-            if (res.error)
-                throw new Error(`smoodly: ${res.error.message}`);
-            const hit = res.data.users.find((u) => u.email?.toLowerCase() === wanted);
-            if (hit)
-                return hit.id;
-            if (res.data.users.length < 200)
-                break;
-        }
-        throw memberErrors.noAccount(email);
-    }
-    async invite(input) {
-        // Self-host: the content client is the auth project's service role, so
-        // the admin API is reachable. A cloud write key never gets here — the
-        // ops refuse behind the console URL first.
-        const sent = await this.db.auth.admin.inviteUserByEmail(input.email, { redirectTo: input.redirectTo });
-        let userId;
-        let invited;
-        if (!sent.error) {
-            userId = sent.data.user.id;
-            invited = true;
-        }
-        else if (sent.error.code === "email_exists" || /already (been )?registered/i.test(sent.error.message)) {
-            userId = await this.userIdByEmail(input.email);
-            invited = false;
-        }
-        else {
-            throw new Error(`smoodly: ${sent.error.message}`);
-        }
-        return { member: await this.upsertRow(userId, input.email, input.role), invited };
-    }
-    async upsertRow(userId, email, role) {
-        const res = await this.db
-            .from("members")
-            .upsert({ user_id: userId, email, role }, { onConflict: "space_id,user_id" })
-            .select("user_id, email, role")
-            .single();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return this.toRecord(res.data);
-    }
-    async createAccount(input) {
-        const created = await this.db.auth.admin.createUser({ email: input.email, password: input.password, email_confirm: true });
-        let userId;
-        if (!created.error) {
-            userId = created.data.user.id;
-        }
-        else if (created.error.code === "email_exists" || /already (been )?registered/i.test(created.error.message)) {
-            // An existing account keeps its password; it only gains the membership.
-            userId = await this.userIdByEmail(input.email);
-        }
-        else {
-            throw new Error(`smoodly: ${created.error.message}`);
-        }
-        return this.upsertRow(userId, input.email, input.role);
-    }
-    async setRole(userId, role) {
-        const res = await this.db.from("members").update({ role }).eq("user_id", userId).select("user_id, email, role").maybeSingle();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        if (!res.data)
-            throw memberErrors.notFound(userId);
-        return this.toRecord(res.data);
-    }
-    async remove(userId) {
-        const res = await this.db.from("members").delete().eq("user_id", userId).select("user_id");
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        if (!res.data || res.data.length === 0)
-            throw memberErrors.notFound(userId);
-    }
-}

package/dist/supabase-path-index.d.ts

@@ -1,30 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import { type Anchors } from "./anchors.ts";
-import { type PathHit, type PathIndex, type PathRow, type PathTarget, type RewriteTarget } from "./path-index.ts";
-export declare class SupabasePathIndex implements PathIndex {
-    private db;
-    private anchors;
-    /** Held by reference: the config's addresses (spec 2026-09-29 anchored paths §2). */
-    constructor(db: SupabaseClient, anchors?: Anchors);
-    private fail;
-    /** Stored rows as callers see them: full URLs; a row whose anchor has no address is left out. */
-    private shown;
-    rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
-    remove(targets: PathTarget[]): Promise<void>;
-    /** Every row at a request URL's candidate keys, in one call, and the winner by precedence (spec §2). */
-    private lookup;
-    private hit;
-    resolve(locale: string, path: string): Promise<PathHit | null>;
-    private rowsOf;
-    /** A locale's rows, sorted by URL in JS: the stored path is not the URL. */
-    private rowsIn;
-    pathsOf(target: PathTarget): Promise<Record<string, string>>;
-    livePathsIn(kind: "page" | "entry", ids: string[], locale: string): Promise<Record<string, string>>;
-    redirectsOf(target: PathTarget): Promise<PathRow[]>;
-    listLive(locale: string): Promise<PathRow[]>;
-    listRedirects(locale: string): Promise<PathRow[]>;
-    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
-    addRedirect(row: PathRow): Promise<void>;
-    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
-    removeRedirect(locale: string, path: string): Promise<void>;
-}

package/dist/supabase-path-index.js

@@ -1,138 +0,0 @@
-import { candidates, fullPath, pickHit, sameUrlKeys } from "./anchors.js";
-import { pathLiveError, pathTakenError } from "./path-index.js";
-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;
-const COLS = "locale, anchor, path, kind, target_id, redirect";
-export class SupabasePathIndex {
-    /** Held by reference: the config's addresses (spec 2026-09-29 anchored paths §2). */
-    constructor(db, anchors = { addresses: {}, homePageSlug: "home", defaultLocale: "en" }) {
-        this.db = db;
-        this.anchors = anchors;
-    }
-    fail(message) {
-        throw new Error(`smoodly: ${message}`);
-    }
-    /** Stored rows as callers see them: full URLs; a row whose anchor has no address is left out. */
-    shown(rows) {
-        const out = [];
-        for (const r of rows) {
-            const path = fullPath(this.anchors, r.anchor, r.path, r.locale);
-            if (path !== null)
-                out.push({ kind: r.kind, id: r.target_id, locale: r.locale, path });
-        }
-        return out;
-    }
-    async rewrite(targets, rows) {
-        const res = await this.db.rpc("smoodly_rewrite_paths", {
-            p_targets: targets.map((t) => ({ kind: t.kind, id: t.id, ...(t.redirectLocales ? { redirect_locales: [...t.redirectLocales] } : {}) })),
-            // `keys`: every stored key that yields the row's full URL (spec §2) — the SQL cannot read the config.
-            p_rows: rows.map((r) => ({
-                locale: r.locale, anchor: r.anchor ?? "", path: r.path, kind: r.kind, id: r.id,
-                keys: sameUrlKeys(this.anchors, r.locale, r.anchor ?? "", r.path),
-            })),
-        });
-        if (res.error) {
-            if (res.error.code === UNIQUE_VIOLATION) {
-                // details: Key (space_id, locale, anchor, path)=(…, en, collection:news, /hello) already exists.
-                const m = /\(space_id, locale, anchor, path\)=\([^,]+, ([^,]+), ([^,]*), (.*)\) already exists/.exec(res.error.details ?? "");
-                throw m ? pathTakenError(m[1], fullPath(this.anchors, m[2], m[3], m[1]) ?? m[3]) : pathTakenError("?", "?");
-            }
-            this.fail(res.error.message);
-        }
-    }
-    async remove(targets) {
-        // Every row of the targets, redirects included: a delete on the target index, not the RPC (which spares redirect rows).
-        for (const t of targets) {
-            const res = await this.db.from("paths").delete().eq("kind", t.kind).eq("target_id", t.id);
-            if (res.error)
-                this.fail(res.error.message);
-        }
-    }
-    /** Every row at a request URL's candidate keys, in one call, and the winner by precedence (spec §2). */
-    async lookup(locale, url) {
-        const { keys, coded } = candidates(this.anchors, locale, url);
-        const res = await this.db.rpc("smoodly_resolve_path", { p_locale: locale, p_keys: keys });
-        if (res.error)
-            this.fail(res.error.message);
-        const rows = res.data;
-        return { rows, hit: pickHit(rows, keys, coded) };
-    }
-    async hit(locale, url) {
-        return (await this.lookup(locale, url)).hit;
-    }
-    async resolve(locale, path) {
-        const row = await this.hit(locale, path);
-        return row ? { kind: row.kind, id: row.target_id, redirect: row.redirect } : null;
-    }
-    async rowsOf(target, redirect) {
-        const res = await this.db.from("paths").select(COLS).eq("kind", target.kind).eq("target_id", target.id).eq("redirect", redirect);
-        if (res.error)
-            this.fail(res.error.message);
-        return this.shown(res.data);
-    }
-    /** A locale's rows, sorted by URL in JS: the stored path is not the URL. */
-    async rowsIn(locale, redirect) {
-        const res = await this.db.from("paths").select(COLS).eq("locale", locale).eq("redirect", redirect).order("anchor").order("path");
-        if (res.error)
-            this.fail(res.error.message);
-        // An editor's live row under a code address is no live URL: visitors never reach it (spec §4).
-        const rows = res.data.filter((r) => redirect || !(r.anchor === "" && candidates(this.anchors, locale, r.path).coded));
-        return this.shown(rows).sort((a, b) => a.path.localeCompare(b.path));
-    }
-    async pathsOf(target) {
-        const out = {};
-        for (const r of await this.rowsOf(target, false))
-            out[r.locale] = r.path;
-        return out;
-    }
-    async livePathsIn(kind, ids, locale) {
-        const uuids = ids.filter((id) => UUID_RE.test(id));
-        if (uuids.length === 0)
-            return {};
-        const out = {};
-        // In chunks: one in() over hundreds of ids would overflow the request URL.
-        for (let i = 0; i < uuids.length; i += 100) {
-            const res = await this.db.from("paths").select(COLS).eq("kind", kind).eq("locale", locale).eq("redirect", false).in("target_id", uuids.slice(i, i + 100));
-            if (res.error)
-                this.fail(res.error.message);
-            for (const r of this.shown(res.data))
-                out[r.id] = r.path;
-        }
-        return out;
-    }
-    redirectsOf(target) {
-        return this.rowsOf(target, true);
-    }
-    listLive(locale) {
-        return this.rowsIn(locale, false);
-    }
-    listRedirects(locale) {
-        return this.rowsIn(locale, true);
-    }
-    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
-    async addRedirect(row) {
-        const { rows, hit: existing } = await this.lookup(row.locale, row.path);
-        if (existing && !existing.redirect)
-            throw pathLiveError(row.locale, row.path);
-        // An editor's page hidden under a code address still holds its row: a redirect never stacks on it.
-        if (rows.some((r) => !r.redirect && r.anchor === "" && r.path === row.path))
-            throw pathLiveError(row.locale, row.path);
-        // Every redirect the URL reaches goes, under any anchor: the new one replaces them all.
-        if (rows.some((r) => r.redirect))
-            await this.removeRedirect(row.locale, row.path);
-        const res = await this.db.from("paths").insert({ locale: row.locale, anchor: "", path: row.path, kind: row.kind, target_id: row.id, redirect: true });
-        if (res.error) {
-            if (res.error.code === UNIQUE_VIOLATION)
-                throw pathLiveError(row.locale, row.path);
-            this.fail(res.error.message);
-        }
-    }
-    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
-    async removeRedirect(locale, path) {
-        for (const k of candidates(this.anchors, locale, path).keys) {
-            const res = await this.db.from("paths").delete().eq("locale", locale).eq("anchor", k.anchor).eq("path", k.path).eq("redirect", true);
-            if (res.error)
-                this.fail(res.error.message);
-        }
-    }
-}

package/dist/supabase-published-store.d.ts

@@ -1,56 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import type { CollectionSchema } from "./collections.ts";
-import type { PublishedEntryRow, PublishedKey, PublishedPageRow, PublishedQuery, PublishedRoute, PublishedStore, PublishedTreeRow, PutOptions } from "./published.ts";
-export declare class SupabasePublishedStore implements PublishedStore {
-    private db;
-    private schemas;
-    private spaceId;
-    /** `collections` encode a `where` on an array field as containment, as SupabaseEntryStore.query does. */
-    constructor(db: SupabaseClient, collections?: CollectionSchema<any>[]);
-    private fail;
-    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
-    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
-    /** The space this client writes in (the service role's is the default): a path delete must not reach past it,
-     *  since the service role passes every policy. Cached for the life of the client; a failed lookup is not. */
-    private space;
-    /** The unique (space, locale, path) index holds one row per address: a row of another id at an incoming address
-     *  (a stale row a capped rename did not reach) is deleted before the upsert. Not atomic with it: rows are derived,
-     *  and a read heals what a failure between the two leaves. One delete per locale in the chunk. */
-    private vacate;
-    /** One request per kind and locale filter: the keys without a locale go in one in(). */
-    private eachGroup;
-    remove(keys: PublishedKey[]): Promise<void>;
-    lastRemovalAt(): Promise<number | null>;
-    /** The space's recorded stamp (DESIGN §3): one row per space in published_models; the key's space, or the
-     *  service role's default one. */
-    recordedModel(): Promise<string | null>;
-    recordModel(model: string): Promise<void>;
-    /** Four head counts (no rows travel): each table's rows, and its rows at another stamp. The policies scope a
-     *  write key to its space; the service role counts the default space's rows by the explicit filter. */
-    countBehind(model: string): Promise<{
-        behind: number;
-        total: number;
-    }>;
-    /** The static build's watermark (spec 2026-10-09 static mode §5): the newest published_at over both tables. */
-    newestPublishedAt(): Promise<number | null>;
-    /** Rows published strictly after `since`: the Deploy tile's "changes waiting". Two head counts. */
-    countPublishedAfter(since: number): Promise<number>;
-    /** The space's last Deploy press, one row in space_deploys (schema v11). */
-    deployRequest(): Promise<{
-        at: number;
-        by: string | null;
-    } | null>;
-    requestDeploy(by: string | null, at?: number): Promise<void>;
-    markStale(keys: PublishedKey[]): Promise<void>;
-    /** A route row is for serving, not for the tree: a page route carries the
-     *  document, model, stale flag and tags; its tree columns are empty, and an
-     *  entry route's `fields` and times likewise. */
-    byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
-    private route;
-    page(id: string, locale: string): Promise<PublishedPageRow | null>;
-    entry(id: string, locale: string): Promise<PublishedEntryRow | null>;
-    /** A list row carries the document, model and stale flag; the raw `fields`
-     *  and the tree columns stay in the table (a list never needs them). */
-    entries(collection: string, q: PublishedQuery): Promise<PublishedEntryRow[]>;
-    tree(locale: string): Promise<PublishedTreeRow[]>;
-}

package/dist/supabase-published-store.js

@@ -1,314 +0,0 @@
-// The Supabase PublishedStore (spec 2026-10-07 delivery model §1, §3): rows in
-// published_pages and published_entries, one address lookup through the
-// published_routes view, lists through smoodly_list_published. Every read is
-// one request; the space is the key's, through the policies as everywhere.
-import { readCurrentSpace } from "./current-space.js";
-import { ARRAY_FIELD_TYPES } from "./entry-store.js";
-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 CHUNK = 100;
-const TREE_COLUMNS = "page_id, parent_id, sort, path, title, has_page, link_fields, model, stale";
-const num = (v) => (v === null ? null : Number(v));
-const iso = (ms) => new Date(ms).toISOString();
-const fromPage = (r) => ({
-    id: r.page_id, locale: r.locale, parentId: r.parent_id, sort: num(r.sort), path: r.path, title: r.title, hasPage: r.has_page,
-    linkFields: r.link_fields, document: r.document, tags: r.tags, model: r.model, stale: r.stale, publishedAt: Date.parse(r.published_at),
-});
-/** `keep` strips published_at from an upsert's payload (PutOptions): the row keeps its own, a new row is dated by the default. */
-function keeping(row, options) {
-    if (!options?.keep)
-        return row;
-    const { published_at: _at, ...rest } = row;
-    return rest;
-}
-const toPage = (r) => ({
-    page_id: r.id, locale: r.locale, parent_id: r.parentId, sort: r.sort, path: r.path, title: r.title, has_page: r.hasPage,
-    link_fields: r.linkFields, document: r.document, tags: r.tags, model: r.model, stale: r.stale, published_at: iso(r.publishedAt),
-});
-const fromEntry = (r) => ({
-    id: r.entry_id, locale: r.locale, collection: r.collection, parentId: r.parent_id, sort: num(r.sort), slug: r.slug, path: r.path,
-    createdAt: Date.parse(r.created_at), updatedAt: Date.parse(r.updated_at), fields: r.fields, document: r.document, tags: r.tags,
-    model: r.model, stale: r.stale, publishedAt: Date.parse(r.published_at),
-});
-const toEntry = (r) => ({
-    entry_id: r.id, locale: r.locale, collection: r.collection, parent_id: r.parentId, sort: r.sort, slug: r.slug, path: r.path,
-    created_at: iso(r.createdAt), updated_at: iso(r.updatedAt), fields: r.fields, document: r.document, tags: r.tags,
-    model: r.model, stale: r.stale, published_at: iso(r.publishedAt),
-});
-export class SupabasePublishedStore {
-    /** `collections` encode a `where` on an array field as containment, as SupabaseEntryStore.query does. */
-    constructor(db, collections = []) {
-        this.db = db;
-        this.schemas = new Map(collections.map((c) => [c.name, c]));
-    }
-    fail(message) {
-        throw new Error(`smoodly: published store: ${message}`);
-    }
-    async putPages(rows, options) {
-        for (let i = 0; i < rows.length; i += CHUNK) {
-            const chunk = rows.slice(i, i + CHUNK);
-            await this.vacate("published_pages", "page_id", chunk);
-            // `keep`: published_at leaves the payload, so an updated row keeps its own and an inserted one takes the default (now).
-            const res = await this.db.from("published_pages").upsert(chunk.map((r) => keeping(toPage(r), options)), { onConflict: "page_id,locale" });
-            if (res.error)
-                this.fail(res.error.message);
-        }
-    }
-    async putEntries(rows, options) {
-        for (let i = 0; i < rows.length; i += CHUNK) {
-            const chunk = rows.slice(i, i + CHUNK);
-            await this.vacate("published_entries", "entry_id", chunk);
-            const res = await this.db.from("published_entries").upsert(chunk.map((r) => keeping(toEntry(r), options)), { onConflict: "entry_id,locale" });
-            if (res.error)
-                this.fail(res.error.message);
-        }
-    }
-    /** The space this client writes in (the service role's is the default): a path delete must not reach past it,
-     *  since the service role passes every policy. Cached for the life of the client; a failed lookup is not. */
-    space() {
-        if (!this.spaceId) {
-            this.spaceId = readCurrentSpace(this.db).catch((e) => {
-                this.spaceId = undefined;
-                throw e;
-            });
-        }
-        return this.spaceId;
-    }
-    /** The unique (space, locale, path) index holds one row per address: a row of another id at an incoming address
-     *  (a stale row a capped rename did not reach) is deleted before the upsert. Not atomic with it: rows are derived,
-     *  and a read heals what a failure between the two leaves. One delete per locale in the chunk. */
-    async vacate(table, column, rows) {
-        const byLocale = new Map();
-        for (const r of rows) {
-            // An id the table cannot hold (no UUID) vacates nothing: an empty `not in ()` is no filter PostgREST accepts.
-            if (r.path === null || !UUID_RE.test(r.id))
-                continue;
-            if (!byLocale.has(r.locale))
-                byLocale.set(r.locale, { paths: [], ids: [] });
-            byLocale.get(r.locale).paths.push(r.path);
-            byLocale.get(r.locale).ids.push(r.id);
-        }
-        if (byLocale.size === 0)
-            return;
-        const space = await this.space();
-        for (const [locale, { paths, ids }] of byLocale) {
-            const res = await this.db.from(table).delete()
-                .eq("space_id", space).eq("locale", locale).in("path", paths)
-                .not(column, "in", `(${ids.join(",")})`);
-            if (res.error)
-                this.fail(res.error.message);
-        }
-    }
-    /** One request per kind and locale filter: the keys without a locale go in one in(). */
-    async eachGroup(keys, act) {
-        const groups = new Map();
-        for (const k of keys) {
-            if (!UUID_RE.test(k.id))
-                continue;
-            const g = `${k.kind}:${k.locale ?? ""}`;
-            if (!groups.has(g))
-                groups.set(g, { kind: k.kind, locale: k.locale, ids: [] });
-            groups.get(g).ids.push(k.id);
-        }
-        for (const { kind, locale, ids } of groups.values()) {
-            const [table, column] = kind === "page" ? ["published_pages", "page_id"] : ["published_entries", "entry_id"];
-            for (let i = 0; i < ids.length; i += CHUNK)
-                await act(table, column, ids.slice(i, i + CHUNK), locale);
-        }
-    }
-    async remove(keys) {
-        if (keys.length === 0)
-            return;
-        let deleted = 0;
-        await this.eachGroup(keys, async (table, column, ids, locale) => {
-            let q = this.db.from(table).delete({ count: "exact" }).in(column, ids);
-            if (locale !== undefined)
-                q = q.eq("locale", locale);
-            const res = await q;
-            if (res.error)
-                this.fail(res.error.message);
-            deleted += res.count ?? 0;
-        });
-        // A row that went is a change the count of newer rows cannot see (spec 2026-10-09 static mode §5): the space's
-        // row keeps when one last happened. A key with no row (a publish vacating a locale that never had one) is no
-        // change. The press's columns are absent from the payload, so they stay as they are.
-        if (deleted === 0)
-            return;
-        const res = await this.db.from("space_deploys").upsert({ space_id: await this.space(), removed_at: new Date().toISOString() }, { onConflict: "space_id" });
-        if (res.error)
-            this.fail(res.error.message);
-    }
-    async lastRemovalAt() {
-        const res = await this.db.from("space_deploys").select("removed_at").eq("space_id", await this.space()).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        const at = res.data?.removed_at;
-        return at ? Date.parse(at) : null;
-    }
-    /** The space's recorded stamp (DESIGN §3): one row per space in published_models; the key's space, or the
-     *  service role's default one. */
-    async recordedModel() {
-        const res = await this.db.from("published_models").select("model").eq("space_id", await this.space()).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data?.model ?? null;
-    }
-    async recordModel(model) {
-        const res = await this.db.from("published_models")
-            .upsert({ space_id: await this.space(), model, recorded_at: new Date().toISOString() }, { onConflict: "space_id" });
-        if (res.error)
-            this.fail(res.error.message);
-    }
-    /** Four head counts (no rows travel): each table's rows, and its rows at another stamp. The policies scope a
-     *  write key to its space; the service role counts the default space's rows by the explicit filter. */
-    async countBehind(model) {
-        const space = await this.space();
-        const count = async (table, behind) => {
-            let q = this.db.from(table).select("*", { count: "exact", head: true }).eq("space_id", space);
-            if (behind)
-                q = q.neq("model", model);
-            const res = await q;
-            if (res.error)
-                this.fail(res.error.message);
-            return res.count ?? 0;
-        };
-        const [pages, entries, pagesBehind, entriesBehind] = await Promise.all([
-            count("published_pages", false), count("published_entries", false), count("published_pages", true), count("published_entries", true),
-        ]);
-        return { behind: pagesBehind + entriesBehind, total: pages + entries };
-    }
-    /** The static build's watermark (spec 2026-10-09 static mode §5): the newest published_at over both tables. */
-    async newestPublishedAt() {
-        const space = await this.space();
-        const latest = async (table) => {
-            const res = await this.db.from(table).select("published_at").eq("space_id", space).order("published_at", { ascending: false }).limit(1).maybeSingle();
-            if (res.error)
-                this.fail(res.error.message);
-            const at = res.data?.published_at;
-            return at ? Date.parse(at) : null;
-        };
-        const [p, e] = await Promise.all([latest("published_pages"), latest("published_entries")]);
-        return p === null && e === null ? null : Math.max(p ?? 0, e ?? 0);
-    }
-    /** Rows published strictly after `since`: the Deploy tile's "changes waiting". Two head counts. */
-    async countPublishedAfter(since) {
-        const space = await this.space();
-        const count = async (table) => {
-            const res = await this.db.from(table).select("*", { count: "exact", head: true }).eq("space_id", space).gt("published_at", new Date(since).toISOString());
-            if (res.error)
-                this.fail(res.error.message);
-            return res.count ?? 0;
-        };
-        const [p, e] = await Promise.all([count("published_pages"), count("published_entries")]);
-        return p + e;
-    }
-    /** The space's last Deploy press, one row in space_deploys (schema v11). */
-    async deployRequest() {
-        const res = await this.db.from("space_deploys").select("requested_at, requested_by").eq("space_id", await this.space()).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        // A removal may have made the row before any press: no requested_at is no press.
-        const row = res.data;
-        return row?.requested_at ? { at: Date.parse(row.requested_at), by: row.requested_by } : null;
-    }
-    async requestDeploy(by, at = Date.now()) {
-        const res = await this.db.from("space_deploys")
-            .upsert({ space_id: await this.space(), requested_at: new Date(at).toISOString(), requested_by: by }, { onConflict: "space_id" });
-        if (res.error)
-            this.fail(res.error.message);
-    }
-    async markStale(keys) {
-        await this.eachGroup(keys, async (table, column, ids, locale) => {
-            let q = this.db.from(table).update({ stale: true }).in(column, ids);
-            if (locale !== undefined)
-                q = q.eq("locale", locale);
-            const res = await q;
-            if (res.error)
-                this.fail(res.error.message);
-        });
-    }
-    /** A route row is for serving, not for the tree: a page route carries the
-     *  document, model, stale flag and tags; its tree columns are empty, and an
-     *  entry route's `fields` and times likewise. */
-    async byAddress(locale, path, globals) {
-        if (globals) {
-            // One call (schema v9): the route row, then the locale's rows of the named global items.
-            const res = await this.db.rpc("smoodly_lookup_address", { p_locale: locale, p_path: path, p_globals: [...globals] });
-            if (res.error)
-                this.fail(res.error.message);
-            const rows = res.data;
-            const first = rows.find((r) => r.kind !== "global");
-            if (!first)
-                return null;
-            const route = this.route({ ...first, kind: first.kind, locale, path });
-            route.globals = rows.filter((r) => r.kind === "global").map((r) => ({
-                id: r.id, locale, collection: r.collection, parentId: null, sort: null, slug: null, path: null, createdAt: 0, updatedAt: 0,
-                fields: {}, document: r.document, tags: r.tags, model: r.model, stale: r.stale, publishedAt: 0,
-            }));
-            return route;
-        }
-        const res = await this.db.from("published_routes").select("kind, id, locale, path, document, model, stale, tags, collection")
-            .eq("locale", locale).eq("path", path).limit(1).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        const r = res.data;
-        return r ? this.route(r) : null;
-    }
-    route(r) {
-        const served = { id: r.id, locale: r.locale, parentId: null, sort: null, path: r.path, tags: r.tags, model: r.model, stale: r.stale, publishedAt: 0 };
-        return r.kind === "page"
-            ? { kind: "page", row: { ...served, title: "", hasPage: true, linkFields: {}, document: r.document } }
-            : { kind: "entry", row: { ...served, collection: r.collection, slug: null, createdAt: 0, updatedAt: 0, fields: {}, document: r.document } };
-    }
-    async page(id, locale) {
-        if (!UUID_RE.test(id))
-            return null;
-        const res = await this.db.from("published_pages").select("*").eq("page_id", id).eq("locale", locale).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? fromPage(res.data) : null;
-    }
-    async entry(id, locale) {
-        if (!UUID_RE.test(id))
-            return null;
-        const res = await this.db.from("published_entries").select("*").eq("entry_id", id).eq("locale", locale).maybeSingle();
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data ? fromEntry(res.data) : null;
-    }
-    /** A list row carries the document, model and stale flag; the raw `fields`
-     *  and the tree columns stay in the table (a list never needs them). */
-    async entries(collection, q) {
-        const schema = this.schemas.get(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 res = await this.db.rpc("smoodly_list_published", {
-            p_collection: collection,
-            p_locale: q.locale,
-            p_where: where,
-            p_order: q.order === undefined ? null : q.order === "manual" ? { by: "manual" } : q.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);
-        return res.data.map((r) => ({
-            id: r.id, locale: q.locale, collection, parentId: null, sort: null, slug: null, path: null, createdAt: 0, updatedAt: 0,
-            fields: {}, document: r.document, tags: [], model: r.model, stale: r.stale, publishedAt: 0,
-        }));
-    }
-    async tree(locale) {
-        const res = await this.db.from("published_pages").select(TREE_COLUMNS).eq("locale", locale)
-            .order("sort", { ascending: true, nullsFirst: false }).order("published_at").order("page_id");
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map((r) => ({
-            id: r.page_id, parentId: r.parent_id, sort: num(r.sort), path: r.path, title: r.title, hasPage: r.has_page, linkFields: r.link_fields,
-            model: r.model, stale: r.stale,
-        }));
-    }
-}