smoodly 0.0.45 → 0.0.46

package/dist/sql.js

@@ -120,6 +120,122 @@ 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");
+
+alter table "published_pages" enable row level security;
+alter table "published_entries" 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 +529,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,35 @@
+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>;
+    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,215 @@
+// 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);
+        });
+    }
+    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.46";

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.46";

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 {};

package/dist/views.js

@@ -0,0 +1,52 @@
+function match(what, key, schemas, views) {
+    const registered = new Map(schemas.map((s) => [s.name, s]));
+    const viewed = new Set();
+    for (const v of views) {
+        const schema = registered.get(v.schema.name);
+        if (!schema)
+            throw new Error(`smoodly: the view for ${what} "${v.schema.name}" has no schema in the config — add its schema to registry.${key}.`);
+        if (schema !== v.schema) {
+            throw new Error(`smoodly: the view for ${what} "${v.schema.name}" is paired with a different schema object than the one in the config — pair it with the registered schema.`);
+        }
+        viewed.add(v.schema.name);
+    }
+    for (const s of schemas) {
+        if (!viewed.has(s.name))
+            throw new Error(`smoodly: ${what} "${s.name}" is registered in the config but has no view — add its component to defineViews({ ${key} }).`);
+    }
+}
+export function defineViews(config, views) {
+    const elements = views.elements ?? [];
+    match("section", "sections", config.registry.sections, views.sections);
+    match("element", "elements", config.registry.elements, elements);
+    match("page type", "pages", config.registry.pages, views.pages.filter((p) => p.schema.kind === "page"));
+    const collections = new Map(config.registry.collections.map((c) => [c.name, c]));
+    const rendered = new Set();
+    for (const p of views.pages) {
+        if (p.schema.kind !== "entryPage")
+            continue;
+        const name = p.schema.collection;
+        if (!collections.has(name))
+            throw new Error(`smoodly: an entry page renders collection "${name}", which is not in registry.collections.`);
+        if (rendered.has(name))
+            throw new Error(`smoodly: two entry pages render collection "${name}" — keep one in defineViews({ pages }).`);
+        rendered.add(name);
+    }
+    for (const c of config.registry.collections) {
+        if (c.path !== undefined && !rendered.has(c.name)) {
+            throw new Error(`smoodly: collection "${c.name}" declares a path but no entry page — add smoodly.entryPage(${c.name}, View) to defineViews({ pages }).`);
+        }
+    }
+    // A bound RichText (createRichText) carries the element components it renders. One it lacks would
+    // vanish from every body without a word, so it is named here (final review of the registration split).
+    const bound = views.RichText?.elements;
+    if (Array.isArray(bound)) {
+        const rendered = new Set(bound.map((e) => e?.schema?.name));
+        for (const e of config.registry.elements) {
+            if ((e.contexts ?? []).includes("richtext") && !rendered.has(e.name)) {
+                throw new Error(`smoodly: element "${e.name}" has a view in defineViews({ elements }), but the bound RichText does not render it — add its component to createRichText({ elements }) in smoodly/richtext.tsx.`);
+            }
+        }
+    }
+    return { sections: views.sections, elements, pages: views.pages, ...(views.RichText ? { RichText: views.RichText } : {}) };
+}

package/dist/zones.d.ts

@@ -1,8 +1,8 @@
 import type { GlobalSchema } from "./global.ts";
-type WithSchema = {
-    schema: {
-        name: string;
-    };
+/** A section schema as a zone needs it. `kind` keeps a component out at compile time: a function has a `name` too. */
+type Named = {
+    kind: string;
+    name: string;
 };
 export type ZonePolicy = {
     kind: "sections";
@@ -22,16 +22,16 @@ export type ZonePolicy = {
     global?: string;
 };
 export declare const z: {
-    sections(components: WithSchema[]): {
+    sections(schemas: Named[]): {
         kind: "sections";
         allow: string[];
     } & {
         max(n: number): ZonePolicy;
     };
     freeform(opts: {
-        sections: WithSchema[] | "*";
+        sections: Named[] | "*";
         custom?: boolean;
     }): ZonePolicy;
-    locked(target: WithSchema | GlobalSchema): ZonePolicy;
+    locked(target: Named | GlobalSchema): ZonePolicy;
 };
 export {};

package/dist/zones.js

@@ -1,10 +1,11 @@
-// Zone policies — the freedom dial. Policies reference paired components
-// directly; only their registered names are stored (plain data).
+// Zone policies — the freedom dial. Policies reference schemas directly;
+// only their registered names are stored (plain data).
+import { schemaOnly } from "./registration.js";
 const isGlobal = (target) => "kind" in target && target.kind === "global";
-const names = (components) => components.map((c) => c.schema.name);
+const names = (schemas) => schemas.map((s) => schemaOnly(s).name);
 export const z = {
-    sections(components) {
-        const allow = names(components);
+    sections(schemas) {
+        const allow = names(schemas);
         return {
             kind: "sections",
             allow,
@@ -24,6 +25,6 @@ export const z = {
                 throw new Error(`smoodly: global item "${target.name}" has no section — a locked zone needs a visual item.`);
             return { kind: "locked", component: target.section, global: target.name };
         }
-        return { kind: "locked", component: target.schema.name };
+        return { kind: "locked", component: schemaOnly(target).name };
     },
 };