smoodly 0.0.12 → 0.0.14

package/dist/richtext-render.js

@@ -1,11 +1,15 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-// The site-side richtext renderer (spec 2026-09-07, list field §5):
-// TipTap JSON → React, a fragment with no wrapper so the developer owns
-// the surrounding element and its class. Pure React, no Node imports, so
-// it works in shared, server and client components alike. Unknown nodes
-// render their children — a document from a later, richer editor degrades
-// instead of crashing. Elements as node views are Phase 3.
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// The site-side richtext renderer (spec 2026-09-07 list field §5; block
+// nodes spec 2026-09-08): TipTap JSON → React, a fragment with no wrapper
+// so the developer owns the surrounding element and its class. Pure
+// React, no Node or Next imports, so it works in shared, server and
+// client components alike. Unknown nodes render their children — a
+// document from a later, richer editor degrades instead of crashing.
+// Block nodes: an `image` node renders through the `image` render prop
+// (default: a figure over a plain <img>); an `element` node renders the
+// paired component named in `elements`, nothing when unknown.
 import { Fragment, createElement } from "react";
+import { ELEMENT_NODE, IMAGE_NODE } from "./richtext-walk.js";
 /** Only schemes an editor's link may carry reach the page: http(s), mailto, tel,
  *  and site-relative targets. Anything else (javascript:, data:, an empty href,
  *  a protocol-relative `//host` or a backslash form `/\host` that a browser
@@ -18,19 +22,27 @@ function safeHref(raw) {
     const href = raw.replace(/[\t\n\r]/g, "").trim();
     return href !== "" && SAFE_HREF.test(href) ? href : null;
 }
-export function RichText({ doc }) {
+/** Lazy by default: body images sit below the fold, and a lazy <img> is
+ *  the one React does not hoist a preload hint for on the server. */
+export function defaultRichTextImage({ image, caption }) {
+    return (_jsxs("figure", { children: [_jsx("img", { src: image.url, width: image.width, height: image.height, alt: image.alt, loading: "lazy" }), caption !== "" && _jsx("figcaption", { children: caption })] }));
+}
+const isResolvedImage = (v) => typeof v === "object" && v !== null && typeof v.url === "string"
+    && typeof v.width === "number" && typeof v.height === "number";
+export function RichText({ doc, elements = [], image = defaultRichTextImage }) {
     const d = doc;
     if (!d || typeof d !== "object" || d.type !== "doc" || !Array.isArray(d.content))
         return null;
-    return _jsx(_Fragment, { children: renderNodes(d.content) });
+    const r = { elements: new Map(elements.map((e) => [e.schema.name, e])), image };
+    return _jsx(_Fragment, { children: renderNodes(d.content, r) });
 }
-function renderNodes(nodes) {
-    return nodes.map((n, i) => _jsx(Fragment, { children: renderNode(n) }, i));
+function renderNodes(nodes, r) {
+    return nodes.map((n, i) => _jsx(Fragment, { children: renderNode(n, r) }, i));
 }
-function renderNode(node) {
+function renderNode(node, r) {
     if (!node || typeof node !== "object")
         return null;
-    const children = Array.isArray(node.content) ? renderNodes(node.content) : null;
+    const children = Array.isArray(node.content) ? renderNodes(node.content, r) : null;
     switch (node.type) {
         case "text": return withMarks(node.text ?? "", node.marks ?? []);
         case "paragraph": return _jsx("p", { children: children });
@@ -43,6 +55,21 @@ function renderNode(node) {
         case "listItem": return _jsx("li", { children: children });
         case "blockquote": return _jsx("blockquote", { children: children });
         case "hardBreak": return _jsx("br", {});
+        case IMAGE_NODE: {
+            const a = (node.attrs ?? {});
+            if (!isResolvedImage(a.image))
+                return null;
+            return r.image({ image: a.image, caption: typeof a.caption === "string" ? a.caption : "" });
+        }
+        case ELEMENT_NODE: {
+            const a = (node.attrs ?? {});
+            const Component = typeof a.name === "string" ? r.elements.get(a.name) : undefined;
+            if (!Component)
+                return null;
+            const fields = a.fields && typeof a.fields === "object" ? a.fields : {};
+            const styles = a.styles && typeof a.styles === "object" ? a.styles : {};
+            return _jsx(Component, { ...fields, styles: styles });
+        }
         default: return children;
     }
 }

package/dist/richtext-walk.d.ts

@@ -0,0 +1,44 @@
+import type { Descriptor } from "./fields.ts";
+export declare const IMAGE_NODE = "image";
+export declare const ELEMENT_NODE = "element";
+export type ImageNodeAttrs = {
+    image?: unknown;
+    caption?: unknown;
+};
+export type ElementNodeAttrs = {
+    name?: unknown;
+    fields?: unknown;
+    styles?: unknown;
+};
+/** A block node as stored — `attrs` is the live object, so a walk may resolve in place. */
+export type BlockNode = {
+    type: string;
+    attrs: Record<string, unknown>;
+};
+/** Every image or element node in document order, at any depth. */
+export declare function richtextBlocks(doc: unknown): BlockNode[];
+/** An element's descriptors by name — what the walks read an element node against. */
+export type ElementSchemas = Record<string, {
+    fields: Record<string, Descriptor>;
+    styles: Record<string, Descriptor>;
+}>;
+type ElementLike = {
+    name: string;
+    fields: Record<string, Descriptor>;
+    styles?: Record<string, Descriptor>;
+} | {
+    schema: {
+        name: string;
+        fields: Record<string, Descriptor>;
+        styles?: Record<string, Descriptor>;
+    };
+};
+export declare function elementSchemas(list: ElementLike[] | undefined): ElementSchemas;
+/** The element schema an element node names, or null for an unknown one. */
+export declare function elementOf(node: BlockNode, elements: ElementSchemas): ElementSchemas[string] | null;
+/** An element node's field and style value sets, for a walk. */
+export declare function elementSets(node: BlockNode, schema: ElementSchemas[string]): {
+    values: Record<string, unknown>;
+    descriptors: Record<string, Descriptor>;
+}[];
+export {};

package/dist/richtext-walk.js

@@ -0,0 +1,46 @@
+export const IMAGE_NODE = "image";
+export const ELEMENT_NODE = "element";
+const isNode = (v) => typeof v === "object" && v !== null && typeof v.type === "string";
+/** Every image or element node in document order, at any depth. */
+export function richtextBlocks(doc) {
+    const out = [];
+    const walk = (n) => {
+        if (!isNode(n))
+            return;
+        if (n.type === IMAGE_NODE || n.type === ELEMENT_NODE) {
+            if (typeof n.attrs !== "object" || n.attrs === null)
+                n.attrs = {};
+            out.push(n);
+        }
+        if (Array.isArray(n.content))
+            for (const c of n.content)
+                walk(c);
+    };
+    walk(doc);
+    return out;
+}
+export function elementSchemas(list) {
+    const out = {};
+    for (const e of list ?? []) {
+        const s = "schema" in e ? e.schema : e;
+        if (!(s.name in out))
+            out[s.name] = { fields: s.fields, styles: s.styles ?? {} };
+    }
+    return out;
+}
+/** The element schema an element node names, or null for an unknown one. */
+export function elementOf(node, elements) {
+    const name = node.attrs.name;
+    return typeof name === "string" ? elements[name] ?? null : null;
+}
+const asRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
+/** An element node's field and style value sets, for a walk. */
+export function elementSets(node, schema) {
+    const a = node.attrs;
+    const fields = asRecord(a.fields);
+    const styles = asRecord(a.styles);
+    return [
+        ...(fields ? [{ values: fields, descriptors: schema.fields }] : []),
+        ...(styles ? [{ values: styles, descriptors: schema.styles }] : []),
+    ];
+}

package/dist/schema.d.ts

@@ -1,4 +1,4 @@
-import type { Descriptor, FieldBuilder, ValueOf } from "./fields.ts";
+import { type Descriptor, type FieldBuilder, type ValueOf } from "./fields.ts";
 import { pageSchema } from "./page.ts";
 export type BuilderMap = Record<string, FieldBuilder<any, any>>;
 export type SectionSchema<F extends BuilderMap = BuilderMap, S extends BuilderMap = BuilderMap> = {

package/dist/schema.js

@@ -1,3 +1,4 @@
+import { describePath, findMatch } from "./fields.js";
 import { pageSchema } from "./page.js";
 function toDescriptors(map) {
     return Object.fromEntries(Object.entries(map ?? {}).map(([k, b]) => [k, b.descriptor]));
@@ -35,6 +36,17 @@ export const schema = {
         return { kind: "section", ...baseSchema(input) };
     },
     element(input) {
-        return { kind: "element", contexts: input.contexts, ...baseSchema(input) };
+        const base = baseSchema(input);
+        // An element inside a document is unreachable to the refs index, which
+        // addresses refs by top-level key (spec 2026-09-08 block nodes §1).
+        if (input.contexts.includes("richtext")) {
+            for (const [key, d] of Object.entries(base.fields)) {
+                const hit = findMatch(d, (sub) => sub.type === "ref" || sub.type === "refList", key);
+                if (hit !== null) {
+                    throw new Error(`smoodly: element "${base.name}" cannot hold a ref (at ${describePath(hit)}) — refs cannot live inside richtext.`);
+                }
+            }
+        }
+        return { kind: "element", contexts: input.contexts, ...base };
     },
 };

package/dist/section-wrapper.js

@@ -1,4 +1,5 @@
 import { createElement } from "react";
+import { NODE_ATTR } from "./marks.js";
 // The root wrapper every section renders through. Owns the mechanical DOM
 // work on the real root element (no extra div): element choice via `as`,
 // string-valued styles emitted as kebab-cased data attributes. Built-in
@@ -10,7 +11,7 @@ export function Section({ as = "section", styles, className, style, children, })
     const { __smoodlyNode, ...rest } = (styles ?? {});
     const dataAttrs = {};
     if (typeof __smoodlyNode === "string")
-        dataAttrs["data-smoodly-node"] = __smoodlyNode;
+        dataAttrs[NODE_ATTR] = __smoodlyNode;
     for (const [key, value] of Object.entries(rest)) {
         if (typeof value === "string")
             dataAttrs[`data-${kebab(key)}`] = value;

package/dist/shared.d.ts

@@ -6,7 +6,7 @@ import type { BuilderMap, NamespaceValues, SectionSchema } from "./schema.ts";
 export declare const SHARED_NODE_TYPE = "shared";
 /** The reserved key a visual item's styles live under in the node's shared JSONB. */
 export declare const STYLES_KEY = "$styles";
-export type SharedSchema<V = Record<string, unknown>> = CollectionSchema<any> & {
+export type SharedSchema<V = Record<string, unknown>, N extends string = string> = CollectionSchema<any, N> & {
     kind: "shared";
     /** The registered section a visual item renders through; absent = an object item. */
     section?: string;
@@ -28,19 +28,19 @@ export declare function sharedLink(node: {
     type: string;
     fields?: Record<string, unknown>;
 }): SharedLink | null;
-type SharedInput = {
-    name: string;
+type SharedInput<N extends string = string> = {
+    name: N;
     title: string;
     versions?: boolean;
 };
-export declare function shared<F extends BuilderMap>(input: SharedInput & {
+export declare function shared<F extends BuilderMap, const N extends string = string>(input: SharedInput<N> & {
     fields: F;
     section?: undefined;
-}): SharedSchema<NamespaceValues<F>>;
-export declare function shared<F extends BuilderMap, St extends BuilderMap>(input: SharedInput & {
+}): SharedSchema<NamespaceValues<F>, N>;
+export declare function shared<F extends BuilderMap, St extends BuilderMap, const N extends string = string>(input: SharedInput<N> & {
     section: PairedComponent<SectionSchema<F, St>, F, St>;
     fields?: undefined;
 }): SharedSchema<NamespaceValues<F> & {
     styles: NamespaceValues<St>;
-}>;
+}, N>;
 export {};

package/dist/site.d.ts

@@ -1,6 +1,7 @@
 import type { AssetStore } from "./asset-store.ts";
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
-import { type EntryRecord, type EntryStore } from "./entry-store.ts";
+import type { Descriptor } from "./fields.ts";
+import { type EntryRecord, type EntryStore, type Where } from "./entry-store.ts";
 import { type LocaleSet, type PathTarget } from "./paths.ts";
 import type { SectionLike } from "./refs.ts";
 import type { PageContext, PageLink, PageTree } from "./render.tsx";
@@ -14,9 +15,21 @@ export type SiteOptions = {
     };
     collections: CollectionSchema<any>[];
     sections: SectionLike[];
+    /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
+    elements?: SectionLike[];
     shared?: SharedSchema[];
     locales: LocaleSet;
     homePageSlug?: string;
+    /** Page shapes (entry pages are ignored): the source of each template's page-field descriptors (spec 2026-09-10 page fields §3). */
+    pages?: ReadonlyArray<SitePageSchema>;
+};
+/** A page registration as the site needs it: the template's page fields. */
+export type SitePageSchema = {
+    schema: {
+        kind: string;
+        name: string;
+        fields?: Record<string, Descriptor>;
+    };
 };
 export type SitePage = {
     kind: "page";
@@ -25,6 +38,8 @@ export type SitePage = {
     tree: PageTree;
     title: string;
     path: string;
+    /** The page's own fields (spec 2026-09-10 page fields §3): resolved, defaults applied. */
+    fields: Record<string, unknown>;
     ancestors: PageLink[];
     children: PageLink[];
     /** locale → path, for metadata alternates: the locales the page is
@@ -48,6 +63,7 @@ export type PageTreeItem = {
     title: string;
     path: string;
     hasPage: boolean;
+    fields: Record<string, unknown>;
     children: PageTreeItem[];
 };
 export type SiteEntryItem = {
@@ -57,10 +73,14 @@ export type SiteEntryItem = {
 export type EntryTreeItem = SiteEntryItem & {
     children: EntryTreeItem[];
 };
+/** `where`, `limit`, `parent` and `order` run in the store (spec 2026-09-11 §3); `draft` reads live rows inside the editor preview. */
 export type EntryQuery = {
     locale?: string;
     parent?: string | null;
     order?: EntryOrder;
+    where?: Where;
+    limit?: number;
+    draft?: boolean;
 };
 export type LoadOptions = {
     draft?: boolean;
@@ -75,16 +95,20 @@ export interface SmoodlySite {
     resolve(locale: string, path: string, options?: LoadOptions): Promise<SiteHit | null>;
     getPagesTree(options?: {
         locale?: string;
+        draft?: boolean;
     }): Promise<PageTreeItem[]>;
     getPage(pathOrId: string, options?: {
         locale?: string;
+        draft?: boolean;
     }): Promise<SitePage | null>;
     getEntries(collection: string, options?: EntryQuery): Promise<SiteEntryItem[]>;
     getEntry(collection: string, idOrPath: string, options?: {
         locale?: string;
+        draft?: boolean;
     }): Promise<SiteEntryItem | null>;
     getEntriesTree(collection: string, options?: {
         locale?: string;
+        draft?: boolean;
     }): Promise<EntryTreeItem[]>;
     /** A shared item's content in a locale (spec 2026-09-07 §4): an object
      *  item's merged fields, or a visual item's section props (fields plus

package/dist/site.js

@@ -1,7 +1,9 @@
-import { entryFieldsIn, schemaOf } from "./entry-store.js";
+import { ARRAY_FIELD_TYPES, entryFieldsIn, localizedKeys, schemaOf } from "./entry-store.js";
 import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
 import { resolveFields, resolveMedia, resolveMediaSets, resolveTree } from "./resolve.js";
+import { elementSchemas } from "./richtext-walk.js";
 import { STYLES_KEY } from "./shared.js";
+import { withDefaults } from "./field-defaults.js";
 /** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
  *  bound to the render locale; the default keeps CMS paths as URLs. */
 export function pageContextOf(hit, toUrl = (p) => p) {
@@ -11,6 +13,7 @@ export function pageContextOf(hit, toUrl = (p) => p) {
         title: hit.title,
         path: hit.path,
         url: toUrl(hit.path),
+        fields: hit.fields,
         ancestors: hit.ancestors.map(withUrl),
         children: hit.children.map(withUrl),
     };
@@ -18,6 +21,7 @@ export function pageContextOf(hit, toUrl = (p) => p) {
 export function createSmoodlySite(options) {
     const locales = options.locales;
     const homePageSlug = options.homePageSlug ?? "home";
+    const elements = elementSchemas(options.elements);
     const pathOpts = { locales, homePageSlug };
     const mounted = options.collections.filter((c) => c.path !== undefined);
     /** The resolver's fetcher, bound to a locale: the merged fields of that
@@ -44,11 +48,43 @@ export function createSmoodlySite(options) {
         const row = node.locales[locale];
         return node.template !== null && row !== undefined && (draft || row.status === "published");
     };
+    const pageFields = (template) => {
+        if (template === null)
+            return {};
+        const p = (options.pages ?? []).find((x) => x.schema.kind === "page" && x.schema.name === template);
+        return p?.schema.fields ?? {};
+    };
+    /** The version whose fields a link shows: the draft's in draft mode, else the published one. */
+    const versionFor = (node, locale, draft) => {
+        const row = node.locales[locale];
+        if (!row || node.template === null)
+            return null;
+        return draft ? row.draftVersionId : row.publishedVersionId;
+    };
+    /** Raw page fields (no asset resolution) of many nodes in ONE store read
+     *  (spec 2026-09-10 page fields §3), defaults applied; `{}` for a folder. */
+    async function linkFields(nodes, locale, draft) {
+        const { pages } = options.stores();
+        const wanted = new Map(); // node id → version id
+        for (const n of nodes) {
+            const v = versionFor(n, locale, draft);
+            if (v)
+                wanted.set(n.id, v);
+        }
+        const byVersion = wanted.size > 0 ? await pages.fieldsOf([...new Set(wanted.values())]) : {};
+        const out = new Map();
+        for (const n of nodes) {
+            const v = wanted.get(n.id);
+            out.set(n.id, n.template === null ? {} : withDefaults(v ? byVersion[v] : undefined, pageFields(n.template)));
+        }
+        return out;
+    }
     /** Only ever called for a node PRESENT in the locale (visible() or an ancestor of one). */
-    const link = (node, byId, locale, draft) => ({
+    const link = (node, byId, locale, draft, fields) => ({
         title: node.locales[locale].title,
         path: pagePath(node, byId, locale, pathOpts),
         hasPage: hasPage(node, locale, draft),
+        fields: fields.get(node.id) ?? {},
     });
     async function loadPage(id, locale, path, draft) {
         const { pages } = options.stores();
@@ -65,17 +101,19 @@ export function createSmoodlySite(options) {
             sections: options.sections,
             collections: options.collections,
             shared: options.shared,
+            elements: options.elements,
             fetch: fetcher(draft, locale),
             assets: assetFetcher(),
+            page: { fields: pageFields(record.template) },
         });
         const all = await pages.listPages();
         const index = new Map(all.map((n) => [n.id, n]));
         const byId = (x) => index.get(x);
         const chain = chainOf(record, byId);
-        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft));
-        const children = all
-            .filter((n) => n.parentId === id && visible(n, locale, draft))
-            .map((n) => link(n, byId, locale, draft));
+        const kids = all.filter((n) => n.parentId === id && visible(n, locale, draft));
+        const fields = await linkFields([...chain.slice(0, -1), ...kids], locale, draft);
+        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft, fields));
+        const children = kids.map((n) => link(n, byId, locale, draft, fields));
         // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
         const paths = Object.fromEntries(Object.entries(await pages.pathsOf(id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
         return {
@@ -85,6 +123,7 @@ export function createSmoodlySite(options) {
             tree,
             title: row.title,
             path,
+            fields: withDefaults(tree.fields, pageFields(record.template)),
             ancestors,
             children,
             paths,
@@ -107,7 +146,7 @@ export function createSmoodlySite(options) {
                 : (await entries.getMany(schema.name, [id], locale, { status: "published" }))[id];
             if (!raw)
                 return null;
-            const fields = await resolveFields(raw, schema.fields, { collections: options.collections, fetch: fetcher(draft, locale), assets: assetFetcher() });
+            const fields = await resolveFields(raw, schema.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), assets: assetFetcher() });
             // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
             const paths = Object.fromEntries(Object.entries(await entries.pathsOf(schema.name, id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
             return { kind: "entry", collection: schema.name, entry: { ...record, fields }, path, paths };
@@ -128,28 +167,55 @@ export function createSmoodlySite(options) {
             path: entryPathRows([record], byId, schema, locales).find((r) => r.locale === locale)?.path ?? null,
         }));
     }
-    /** Public in a locale: its row exists there and is published. */
-    const publicEntry = (e, locale) => e.locales[locale]?.status === "published";
     async function getEntries(collection, o = {}) {
         const schema = schemaOf(options.collections, collection);
         const locale = localeOf(o);
+        const draft = o.draft ?? false;
         const { entries } = options.stores();
-        const all = await entries.list(collection, { order: o.order });
-        const wanted = all.filter((e) => publicEntry(e, locale) && (o.parent === undefined || e.parentId === o.parent));
-        const published = await entries.getMany(collection, wanted.map((e) => e.id), locale, { status: "published" });
+        // A filter that silently matched nothing would be worse than an error (spec 2026-09-11 §3).
+        for (const key of Object.keys(o.where ?? {})) {
+            if (key === "slug" || localizedKeys(schema).includes(key)) {
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is localized — where filters shared fields only (spec 2026-09-11 §3).`);
+            }
+            if (!(key in schema.fields))
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is not a field of the collection.`);
+            // Any-of reads the text form of the whole field (PostgREST's `->>`), which for
+            // an array is its JSON — `["a"]` never matches "a" — so refuse rather than match nothing.
+            if (Array.isArray(o.where[key]) && ARRAY_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is array-valued — any-of is for scalar fields; pass one value to match entries containing it.`);
+            }
+        }
+        if (o.limit !== undefined && (!Number.isInteger(o.limit) || o.limit < 0)) {
+            throw new Error(`smoodly: getEntries("${collection}"): limit must be a non-negative integer.`);
+        }
+        // The store filters, orders and limits (spec 2026-09-11 §3): the locale
+        // gate — presence in draft mode, published otherwise — is part of the
+        // query, so `limit` counts rows that are really there.
+        const inLocale = await entries.list(collection, {
+            order: o.order, where: o.where, limit: o.limit,
+            ...(o.parent !== undefined ? { parent: o.parent } : {}),
+            ...(draft ? { locale } : { status: "published", locale }),
+        });
+        // Paths need every ancestor: a tree collection reads the whole collection for that, a flat one does not.
+        const all = schema.tree ? await entries.list(collection) : inLocale;
+        const fieldsById = draft
+            ? Object.fromEntries(inLocale.map((e) => [e.id, entryFieldsIn(e, locale)]))
+            : await entries.getMany(collection, inLocale.map((e) => e.id), locale, { status: "published" });
         // Refs stay ids on the content API; media resolves (one asset round for
         // the whole list), because a list page's cards need their image URLs.
         const fetchAssets = assetFetcher();
         if (fetchAssets)
-            await resolveMediaSets(Object.values(published).map((values) => ({ values, descriptors: schema.fields })), fetchAssets);
-        return entryItems(schema, wanted, all, locale, published);
+            await resolveMediaSets(Object.values(fieldsById).map((values) => ({ values, descriptors: schema.fields })), fetchAssets, elements);
+        return entryItems(schema, inLocale, all, locale, fieldsById);
     }
     const api = {
         async getPagesTree(o) {
             const locale = localeOf(o);
+            const draft = o?.draft ?? false;
             const all = await options.stores().pages.listPages();
-            const shown = all.filter((n) => visible(n, locale, false));
+            const shown = all.filter((n) => visible(n, locale, draft));
             const index = new Map(shown.map((n) => [n.id, n]));
+            const fields = await linkFields(shown, locale, draft);
             const toItem = (node) => ({
                 id: node.record.id,
                 title: node.record.locales[locale].title,
@@ -157,7 +223,8 @@ export function createSmoodlySite(options) {
                 // buildPageTree's nullable path is never null here; pagePath is
                 // the same derivation and keeps the type honest.
                 path: node.path ?? pagePath(node.record, (x) => index.get(x), locale, pathOpts),
-                hasPage: hasPage(node.record, locale, false),
+                hasPage: hasPage(node.record, locale, draft),
+                fields: fields.get(node.record.id) ?? {},
                 children: node.children.map(toItem),
             });
             return buildPageTree(shown, locale, pathOpts).map(toItem);
@@ -167,7 +234,7 @@ export function createSmoodlySite(options) {
             const path = pathOrId.startsWith("/") ? pathOrId : (await options.stores().pages.pathsOf(pathOrId))[locale];
             if (!path)
                 return null;
-            const hit = await site.resolve(locale, path);
+            const hit = await site.resolve(locale, path, { draft: o?.draft ?? false });
             return hit?.kind === "page" ? hit : null;
         },
         getEntries,
@@ -175,10 +242,10 @@ export function createSmoodlySite(options) {
             schemaOf(options.collections, collection); // an unknown collection is a wiring error on every branch
             const locale = localeOf(o);
             if (idOrPath.startsWith("/")) {
-                const hit = await site.resolve(locale, idOrPath);
+                const hit = await site.resolve(locale, idOrPath, { draft: o?.draft ?? false });
                 return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path } : null;
             }
-            const items = await getEntries(collection, { locale });
+            const items = await getEntries(collection, { locale, draft: o?.draft ?? false });
             const byId = items.find((i) => i.entry.id === idOrPath);
             if (byId)
                 return byId;
@@ -188,7 +255,7 @@ export function createSmoodlySite(options) {
             return items.find((i) => i.entry.parentId === null && entrySegment(i.entry, locale) === idOrPath) ?? null;
         },
         async getEntriesTree(collection, o) {
-            const items = await getEntries(collection, { locale: localeOf(o) });
+            const items = await getEntries(collection, { locale: localeOf(o), draft: o?.draft ?? false });
             const build = (parentId) => items.filter((i) => i.entry.parentId === parentId).map((i) => ({ ...i, children: build(i.entry.id) }));
             return build(null);
         },
@@ -207,13 +274,13 @@ export function createSmoodlySite(options) {
                 : (await entries.getMany(item.name, [record.id], locale, { status: "published" }))[record.id];
             if (!raw)
                 return null;
-            const fields = await resolveFields(raw, item.fields, { collections: options.collections, fetch: fetcher(draft, locale), assets: assetFetcher() });
+            const fields = await resolveFields(raw, item.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), assets: assetFetcher() });
             if (!item.section)
                 return fields;
             const { [STYLES_KEY]: styles, ...rest } = fields;
             const fetch = assetFetcher();
             if (fetch && styles && typeof styles === "object")
-                await resolveMedia(styles, sectionStyles(item.section), fetch);
+                await resolveMedia(styles, sectionStyles(item.section), fetch, elements);
             return { ...rest, styles: styles !== null && typeof styles === "object" ? styles : {} };
         },
     };

package/dist/store.d.ts

@@ -78,6 +78,9 @@ export interface PageStore {
     publish(id: string, locale: string): Promise<PageRecord>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
+    /** The page fields of many versions in ONE read (spec 2026-09-10 page fields §3):
+     *  versionId → `tree.fields ?? {}`; ids that do not exist are absent. */
+    fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
     listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;
 }
@@ -86,6 +89,8 @@ export interface PageStore {
  * written; without `entries` publishing is not integrity-checked. */
 export type PageStoreOptions = {
     sections?: SectionLike[];
+    /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
+    elements?: SectionLike[];
     entries?: EntryStore;
     /** The shared URL index (one instance for pages AND entries). */
     paths?: PathIndex;
@@ -123,7 +128,7 @@ export declare function localeRow(page: PageRecord, locale: string): PageLocale;
 /** A page's refs rows cover EVERY live tree — each locale's draft and
  * published trees — so an entry stays delete-guarded while any of them
  * shows it. Callers dedupe on write (the SQL PK does it for real). */
-export declare function pageRefEdges(trees: PageTree[], sections: SectionLike[]): RefEdge[];
+export declare function pageRefEdges(trees: PageTree[], sections: SectionLike[], elements?: SectionLike[]): RefEdge[];
 /** The publish-integrity gate (DESIGN.md §3), per locale: a page must not
  * go live in a locale showing entries the published site cannot resolve
  * THERE — every referenced entry must exist, have a row in that locale,
@@ -177,6 +182,7 @@ export declare class MemoryPageStore implements PageStore {
     saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
     publish(id: string, locale: string): Promise<PageRecord>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
+    fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
     listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;

package/dist/store.js

@@ -50,10 +50,10 @@ export function localeRow(page, locale) {
 /** A page's refs rows cover EVERY live tree — each locale's draft and
  * published trees — so an entry stays delete-guarded while any of them
  * shows it. Callers dedupe on write (the SQL PK does it for real). */
-export function pageRefEdges(trees, sections) {
+export function pageRefEdges(trees, sections, elements) {
     const edges = [];
     for (const tree of trees)
-        edges.push(...collectTreeRefs(tree, sections));
+        edges.push(...collectTreeRefs(tree, sections, elements));
     return edges;
 }
 /** The publish-integrity gate (DESIGN.md §3), per locale: a page must not
@@ -159,10 +159,10 @@ export class MemoryPageStore {
         return trees;
     }
     writeRefs(page) {
-        const { sections, refs } = this.options;
+        const { sections, elements, refs } = this.options;
         if (!sections || !refs)
             return;
-        refs.rewrite({ sourceKind: "page", sourceId: page.id }, pageRefEdges(this.liveTrees(page), sections));
+        refs.rewrite({ sourceKind: "page", sourceId: page.id }, pageRefEdges(this.liveTrees(page), sections, elements));
     }
     newVersion(pageId, locale, tree) {
         const version = { id: uid(), pageId, locale, tree: structuredClone(tree), createdAt: Date.now() };
@@ -410,6 +410,15 @@ export class MemoryPageStore {
             return null;
         return structuredClone(this.versions.get(row.draftVersionId)?.tree ?? null);
     }
+    async fieldsOf(versionIds) {
+        const out = {};
+        for (const id of versionIds) {
+            const v = this.versions.get(id);
+            if (v)
+                out[id] = structuredClone(v.tree.fields ?? {});
+        }
+        return out;
+    }
     async getPublishedTree(id, locale) {
         const row = this.pages.get(id)?.locales[locale];
         if (!row?.publishedVersionId)