smoodly 0.0.45 → 0.0.47

package/dist/sql-space.js

@@ -19,6 +19,11 @@ export const CONTENT_TABLES = [
     "paths",
     "assets",
 ];
+/** The delivery model's derived tables (spec 2026-10-07 §1): policy-covered and
+ *  space-stamped like content, but not transferred (export skips them, import
+ *  rebuilds them) and not counted toward the row cap, since they are derived.
+ *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current. */
+export const DELIVERY_TABLES = ["published_pages", "published_entries", "published_models"];
 export function currentSpaceSQL() {
     return `
 -- The space a request acts in: the key's claim in Smoodly Cloud, the
@@ -55,7 +60,7 @@ const WRITE = `${OWN} and (select "smoodly_key_kind"()) = 'write'`;
  *  policy, which is also their only select. */
 export function contentPoliciesSQL() {
     const statements = [];
-    for (const table of [...CONTENT_TABLES, "members"]) {
+    for (const table of [...CONTENT_TABLES, ...DELIVERY_TABLES, "members"]) {
         if (table === "refs" || table === "members") {
             statements.push(`drop policy if exists "smoodly_write" on "${table}";\n` +
                 `create policy "smoodly_write" on "${table}" for all\n` +
@@ -190,7 +195,7 @@ $$;`.trim());
         statements.push(`create index if not exists "${table}_space_idx" on "${table}" ("space_id");`);
     }
     // Trigger names sort a_ before b_: same-event triggers fire alphabetically.
-    for (const table of [...CONTENT_TABLES, "members"]) {
+    for (const table of [...CONTENT_TABLES, ...DELIVERY_TABLES, "members"]) {
         statements.push(`drop trigger if exists "smoodly_a_set_space" on "${table}";\n` +
             `create trigger "smoodly_a_set_space" before insert on "${table}"\n` +
             `  for each row execute function "smoodly_set_space"();`);
@@ -270,9 +275,10 @@ export function mediaPoliciesSQL() {
  *  public. `smoodly_current_space` is NOT here — the stores read it through
  *  rpc(). Last in the schema, after every definition exists. */
 export function grantsSQL() {
-    // smoodly_list_entries is callable by every role on purpose: invoker
-    // rights and the read policies decide what a key sees (spec 2026-09-29
-    // content API contract §5), so there is nothing to revoke.
+    // smoodly_list_entries and smoodly_list_published are callable by every
+    // role on purpose: invoker rights and the read policies decide what a key
+    // sees (spec 2026-09-29 content API contract §5), so there is nothing to
+    // revoke; the published_routes view is security_invoker for the same reason.
     return [
         `revoke execute on function "smoodly_reorder"(text, uuid[]) from public, anon;`,
         `revoke execute on function "smoodly_reorder_pages"(uuid[]) from public, anon;`,

package/dist/sql.d.ts

@@ -10,4 +10,6 @@ export declare function foreignKeyIndexesSQL(): string;
  *  §5). Invoker rights, so RLS decides what a key sees. Defined after the
  *  space layer, whose `smoodly_key_kind` it calls. */
 export declare function listEntriesSQL(): string;
+/** The delivery model (spec 2026-10-07 §1): two derived tables, a list function over the raw snapshot, a routes view. */
+export declare function publishedTablesSQL(): string;
 export declare function coreTablesSQL(): string;

package/dist/sql.js

@@ -9,7 +9,7 @@
 // locale (spec 2026-09-06 §7); a versioned collection reads its
 // fields from the published snapshot.
 import { SEO_KEY } from "./seo.js";
-import { currentSpaceSQL, grantsSQL, SPACE_COL, spaceLayerSQL } from "./sql-space.js";
+import { currentSpaceSQL, grantsSQL, SPACE_COL, spaceLayerSQL, DEFAULT_SPACE } from "./sql-space.js";
 const snake = (s) => s.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
 const q = (s) => `"${s}"`;
 // Casts are fine in views.
@@ -120,6 +120,131 @@ create or replace function "smoodly_list_entries"(
   limit p_limit;
 $$;`.trim();
 }
+/** The delivery model (spec 2026-10-07 §1): two derived tables, a list function over the raw snapshot, a routes view. */
+export function publishedTablesSQL() {
+    return `
+-- The delivery model (spec 2026-10-07): Publish writes the finished document of a page, an entry
+-- or a global here; a live read is one lookup. Derived and rebuildable from the editing tables.
+create table if not exists "published_pages" (
+  ${SPACE_COL},
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "path" text,
+  "title" text not null,
+  "has_page" boolean not null,
+  "link_fields" jsonb not null default '{}'::jsonb,
+  "document" jsonb,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+create unique index if not exists "published_pages_address_idx"
+  on "published_pages" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_pages_tree_idx"
+  on "published_pages" ("space_id", "locale", "parent_id", "sort");
+
+create table if not exists "published_entries" (
+  ${SPACE_COL},
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "collection" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "slug" text,
+  "path" text,
+  "created_at" timestamptz not null,
+  "updated_at" timestamptz not null,
+  "fields" jsonb not null,
+  "document" jsonb not null,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+create index if not exists "published_entries_list_idx"
+  on "published_entries" ("space_id", "collection", "locale");
+create unique index if not exists "published_entries_address_idx"
+  on "published_entries" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_entries_fields_idx"
+  on "published_entries" using gin ("fields");
+
+-- The document stamp a space recorded as current (DESIGN §3, schema v10): set by \`npx smoodly rebuild\`
+-- and by the first writer into an empty record; only a reader at this stamp rewrites the rows above.
+create table if not exists "published_models" (
+  "space_id" uuid primary key default ${DEFAULT_SPACE},
+  "model" text not null,
+  "recorded_at" timestamptz not null default now()
+);
+
+alter table "published_pages" enable row level security;
+alter table "published_entries" enable row level security;
+alter table "published_models" enable row level security;
+
+-- smoodly_list_entries without the draft branch, over the delivery table (spec 2026-10-07 §3):
+-- \`where\` and \`order\` read the raw published snapshot, the row answers with its document.
+-- Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_list_published"(
+  p_collection text, p_locale text, p_where jsonb, p_order jsonb,
+  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
+) returns table ("id" uuid, "document" jsonb, "model" text, "stale" boolean) language sql stable set search_path = public as $$
+  with shown as (
+    select p."entry_id" as "id", p."sort", p."created_at", p."updated_at", p."fields", p."document", p."model", p."stale"
+    from "published_entries" p
+    where p."collection" = p_collection and p."locale" = p_locale
+      and (not p_has_parent or p."parent_id" is not distinct from p_parent)
+      and (p_ids is null or p."entry_id" = any(p_ids))
+  )
+  select s."id", s."document", s."model", s."stale" from shown s
+  where not exists (
+    select 1 from jsonb_each(coalesce(p_where, '{}'::jsonb)) w
+    where not (case when w.value ? 'in'
+                    then (s."fields" ->> w.key) = any (select jsonb_array_elements_text(w.value -> 'in'))
+                    else s."fields" @> jsonb_build_object(w.key, w.value -> 'contains') end))
+  order by
+    case when p_order ->> 'by' = 'manual' then s."sort" end asc nulls last,
+    case when p_order ->> 'direction' = 'asc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end asc nulls last,
+    case when p_order ->> 'direction' = 'desc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end desc nulls last,
+    s."created_at" asc, s."id" asc
+  limit p_limit;
+$$;
+
+-- One lookup for any address (spec 2026-10-07 §3): a page or an entry, under the caller's own policies.
+create or replace view "published_routes" with (security_invoker = true) as
+  select "space_id", "locale", "path", 'page' as "kind", "page_id" as "id", "document", "model", "stale", "tags", null::text as "collection"
+  from "published_pages" where "path" is not null and "has_page"
+  union all
+  select "space_id", "locale", "path", 'entry' as "kind", "entry_id" as "id", "document", "model", "stale", "tags", "collection"
+  from "published_entries" where "path" is not null;
+
+-- The address and the locale's global items in one call (schema v9; register 2026-10-07: a miss was two
+-- rounds, the page then the layout's globals). The route row first, kind 'page' or 'entry'; then one row per
+-- named global, kind 'global', the collection its name. A miss answers nothing: the globals ride with a page
+-- only. Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_lookup_address"(p_locale text, p_path text, p_globals text[])
+returns table ("kind" text, "id" uuid, "collection" text, "document" jsonb, "model" text, "stale" boolean, "tags" text[])
+language sql stable set search_path = public as $$
+  with route as (
+    select r."kind", r."id", r."collection", r."document", r."model", r."stale", r."tags"
+    from "published_routes" r where r."locale" = p_locale and r."path" = p_path limit 1
+  )
+  select * from route
+  union all
+  select 'global' as "kind", e."entry_id", e."collection", e."document", e."model", e."stale", e."tags"
+  from "published_entries" e
+  where e."locale" = p_locale and e."collection" = any(coalesce(p_globals, '{}'::text[]))
+    and exists (select 1 from route);
+$$;
+`.trim();
+}
 export function coreTablesSQL() {
     return [
         // The trigger/policy blocks below drop-before-create so the migration is
@@ -413,6 +538,7 @@ alter table "paths" enable row level security;
 alter table "assets" enable row level security;
 alter table "smoodly_meta" enable row level security;
 `.trim(),
+        publishedTablesSQL(),
         spaceLayerSQL(),
         listEntriesSQL(),
         grantsSQL(),

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import type { PageTree } from "./render.tsx";
+import type { PageTree } from "./page-context.ts";
 import type { EntryStore } from "./entry-store.ts";
 import type { Addresses } from "./addresses.ts";
 import type { Anchors } from "./anchors.ts";

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

@@ -0,0 +1,45 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { CollectionSchema } from "./collections.ts";
+import type { PublishedEntryRow, PublishedKey, PublishedPageRow, PublishedQuery, PublishedRoute, PublishedStore, PublishedTreeRow } 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[]): Promise<void>;
+    putEntries(rows: PublishedEntryRow[]): 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>;
+    /** 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;
+    }>;
+    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

@@ -0,0 +1,247 @@
+// 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),
+});
+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) {
+        for (let i = 0; i < rows.length; i += CHUNK) {
+            const chunk = rows.slice(i, i + CHUNK);
+            await this.vacate("published_pages", "page_id", chunk);
+            const res = await this.db.from("published_pages").upsert(chunk.map(toPage), { onConflict: "page_id,locale" });
+            if (res.error)
+                this.fail(res.error.message);
+        }
+    }
+    async putEntries(rows) {
+        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(toEntry), { 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) {
+        await this.eachGroup(keys, async (table, column, ids, locale) => {
+            let q = this.db.from(table).delete().in(column, ids);
+            if (locale !== undefined)
+                q = q.eq("locale", locale);
+            const res = await q;
+            if (res.error)
+                this.fail(res.error.message);
+        });
+    }
+    /** 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 };
+    }
+    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,
+        }));
+    }
+}

package/dist/supabase-store.d.ts

@@ -1,6 +1,6 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import { type AddLocaleOptions, type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion, type PageScan } from "./store.ts";
-import type { PageTree } from "./render.tsx";
+import type { PageTree } from "./page-context.ts";
 import type { PathRow } from "./path-index.ts";
 import { type DraftToken } from "./draft-token.ts";
 import { type PathTarget } from "./paths.ts";

package/dist/toolset.d.ts

@@ -15,10 +15,8 @@ export declare function toolset(input: {
     nodes?: readonly ToolsetNode[];
     /** Registered Elements embeddable in this toolset, by value (spec 2026-09-08 block nodes §1). */
     elements?: {
-        schema: {
-            name: string;
-            contexts?: readonly string[];
-        };
+        name: string;
+        contexts: readonly string[];
     }[];
 }): Toolset;
 /** The resolved toolset the widget reads: which marks and nodes an editor

package/dist/toolset.js

@@ -1,3 +1,4 @@
+import { schemaOnly } from "./registration.js";
 // Toolsets are plain shared values, not registrations (DESIGN.md §3): a
 // richtext field imports one by value and it travels inside the field
 // descriptor to the admin. The vocabulary is typed and checked at
@@ -30,12 +31,13 @@ export function toolset(input) {
         out.nodes = [...input.nodes];
     }
     if (input.elements) {
-        for (const e of input.elements) {
-            if (!(e.schema.contexts ?? []).includes("richtext")) {
-                throw new Error(`smoodly: element "${e.schema.name}" is not registered for the richtext context — add "richtext" to its contexts.`);
+        const schemas = input.elements.map((e) => schemaOnly(e));
+        for (const e of schemas) {
+            if (!(e.contexts ?? []).includes("richtext")) {
+                throw new Error(`smoodly: element "${e.name}" is not registered for the richtext context — add "richtext" to its contexts.`);
             }
         }
-        out.elements = input.elements.map((e) => e.schema.name);
+        out.elements = schemas.map((e) => e.name);
     }
     return out;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.45";
+export declare const SMOODLY_VERSION = "0.0.47";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/write-version.mjs from package.json — do not edit.
-export const SMOODLY_VERSION = "0.0.45";
+export const SMOODLY_VERSION = "0.0.47";

package/dist/view-props.d.ts

@@ -0,0 +1,40 @@
+import type { CollectionSchema } from "./collections.ts";
+import type { BuilderMap, Materialize, Values } from "./schema.ts";
+import type { StyleProps } from "./styles.ts";
+import type { EntryItem } from "./read-shapes.ts";
+import type { PageContext, ZoneContent } from "./page-context.ts";
+/** What the view receives. A page view gets its zones and where it sits
+ * in the tree; a section/element view gets field values flat, settings
+ * complete (defaults filled) and Smoodly's styles steps as stored (Default
+ * stores nothing — spec 2026-09-14 §2). The page branch keys on `kind` — an
+ * optional-only check would match section schemas too, since a type
+ * lacking `__zones` still extends `{ __zones?: X }`. */
+export type Props<S> = S extends {
+    kind: "page";
+    __zones?: infer Z extends Record<string, unknown>;
+    __fields?: infer F extends BuilderMap;
+} ? {
+    zones: Record<keyof Z & string, ZoneContent>;
+    page: PageContext<Values<F>>;
+} : S extends {
+    __f?: infer F extends BuilderMap;
+    __s?: infer St extends BuilderMap;
+} ? Values<F> & {
+    settings: Values<St>;
+    styles: StyleProps;
+} : never;
+export type EntryPageSchema = {
+    kind: "entryPage";
+    name: string;
+    collection: string;
+};
+/** What an entry page renders: the entry as a read returns it — its path, locale and
+ *  locale alternates ride on it (spec 2026-09-29 content API contract §3). */
+export type EntryPageProps<F = Record<string, unknown>> = {
+    entry: EntryItem<F>;
+};
+/** A collection's fields as a read returns them (refs resolved, media as images): an Astro entry page's
+ *  `entry: EntryItem<EntryFields<typeof articles>>`, what React's `entryPage(articles, View)` infers. */
+export type EntryFields<C extends CollectionSchema<any>> = {
+    [K in keyof NonNullable<C["__entry"]>]: Materialize<NonNullable<C["__entry"]>[K]>;
+};

package/dist/view-props.js

@@ -0,0 +1 @@
+export {};

package/dist/views.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentType } from "react";
+import type { ResolvedConfig } from "./config.ts";
+/** A paired section or element: a component carrying its schema. */
+type ViewOf = ComponentType<any> & {
+    schema: {
+        name: string;
+    };
+};
+/** A paired page type or entry page. */
+type PageViewOf = ((props: any) => unknown) & {
+    schema: {
+        kind: string;
+        name: string;
+        collection?: string;
+    };
+};
+export type ViewsInput<S extends ViewOf = ViewOf, E extends ViewOf = ViewOf, P extends PageViewOf = PageViewOf> = {
+    sections: S[];
+    elements?: E[];
+    /** Page types and entry pages alike: everything that renders a URL. */
+    pages: P[];
+    /** The project's bound RichText, for the custom section's columns (spec 2026-09-14 §6). */
+    RichText?: ComponentType<{
+        doc: unknown;
+    }>;
+};
+export type Views<S extends ViewOf = ViewOf, E extends ViewOf = ViewOf, P extends PageViewOf = PageViewOf> = {
+    sections: S[];
+    elements: E[];
+    pages: P[];
+    RichText?: ComponentType<{
+        doc: unknown;
+    }>;
+};
+export declare function defineViews<S extends ViewOf, E extends ViewOf, P extends PageViewOf>(config: ResolvedConfig, views: ViewsInput<S, E, P>): Views<S, E, P>;
+export {};