smoodly 0.0.12 → 0.0.14

package/dist/fields.d.ts

@@ -4,6 +4,25 @@ export type Descriptor = {
     type: string;
     [key: string]: unknown;
 };
+/** A choice: what is stored (`value`) and what the editor reads (`label`). */
+export type Option<V extends string = string> = {
+    value: V;
+    label: string;
+};
+/** What a schema may write: an option object, or a bare string as shorthand for value = label. */
+export type OptionInput<V extends string = string> = V | Option<V>;
+/** The stored value of one option input. */
+export type OptionValue<T> = T extends string ? T : T extends {
+    value: infer V extends string;
+} ? V : never;
+/** Normalizes a schema's option list to objects; refuses an empty list,
+ *  since a choice with nothing to choose is a schema bug (spec 2026-09-10
+ *  page fields §1). */
+export declare function normalizeOptions<V extends string>(options: readonly OptionInput<V>[]): Option<V>[];
+/** The options of a descriptor in either shape (objects since spec 2026-09-10; bare strings in older data). */
+export declare function optionsOf(options: unknown): Option[];
+/** The values a stored choice may take. */
+export declare const optionValues: (options: unknown) => string[];
 export type FieldBuilder<Value = unknown, Flags extends BuilderFlags = {}> = {
     readonly descriptor: Descriptor;
     optional(): FieldBuilder<Value, Flags & {
@@ -42,6 +61,10 @@ type NotLocalized<B> = B extends {
 } ? Fl extends {
     localized: true;
 } ? never : B : B;
+export declare const describePath: (path: string) => string;
+/** First path at which `matches` is true of the descriptor, walking into
+ *  object subfields and a list's item, or null. */
+export declare function findMatch(d: Descriptor, matches: (d: Descriptor) => boolean, path?: string): string | null;
 export declare const f: {
     text: () => FieldBuilder<string, {}>;
     link: () => FieldBuilder<string, {}>;
@@ -61,7 +84,13 @@ export declare const f: {
         toolset?: Toolset;
     }) => FieldBuilder<unknown, {}>;
     dataAttributes: () => FieldBuilder<Record<string, string>, {}>;
-    select: <const O extends readonly string[]>(options: O) => FieldBuilder<O[number], {}>;
+    boolean: () => FieldBuilder<boolean, {}>;
+    /** One value from a list, shown as a dropdown. */
+    select: <const O extends readonly OptionInput[]>(options: O) => FieldBuilder<OptionValue<O[number]>, {}>;
+    /** One value from a list, shown as a radio group. */
+    radio: <const O extends readonly OptionInput[]>(options: O) => FieldBuilder<OptionValue<O[number]>, {}>;
+    /** Several values from a list, stored as an array, shown as a checkbox list. */
+    checkboxes: <const O extends readonly OptionInput[]>(options: O) => FieldBuilder<OptionValue<O[number]>[], {}>;
     object: <S extends Record<string, FieldBuilder<any, any>>>(shape: S & { [K in keyof S]: NotLocalized<S[K]>; }) => FieldBuilder<{ [K in keyof S]: ValueOf<S[K]>; }, {}>;
     /** A repeating item: any builder, but no list at any depth inside the item
      *  — a list in an object in a list is still a nested list on screen, and a

package/dist/fields.js

@@ -3,6 +3,30 @@
 // keyed by descriptor type. Chaining is immutable.
 import { DEFAULT_TOOLSET } from "./toolset.js";
 import { parseAspect } from "./media.js";
+/** Normalizes a schema's option list to objects; refuses an empty list,
+ *  since a choice with nothing to choose is a schema bug (spec 2026-09-10
+ *  page fields §1). */
+export function normalizeOptions(options) {
+    if (!Array.isArray(options) || options.length === 0)
+        throw new Error("smoodly: a choice field needs at least one option.");
+    return options.map((o) => (typeof o === "string" ? { value: o, label: o } : { value: o.value, label: o.label }));
+}
+/** The options of a descriptor in either shape (objects since spec 2026-09-10; bare strings in older data). */
+export function optionsOf(options) {
+    if (!Array.isArray(options))
+        return [];
+    return options.flatMap((o) => {
+        if (typeof o === "string")
+            return [{ value: o, label: o }];
+        if (o && typeof o === "object" && typeof o.value === "string") {
+            const opt = o;
+            return [{ value: opt.value, label: typeof opt.label === "string" ? opt.label : opt.value }];
+        }
+        return [];
+    });
+}
+/** The values a stored choice may take. */
+export const optionValues = (options) => optionsOf(options).map((o) => o.value);
 function builder(descriptor) {
     const chain = (patch) => builder({ ...descriptor, ...patch });
     return {
@@ -22,10 +46,10 @@ function builder(descriptor) {
         tab: (tab) => chain({ tab }),
     };
 }
-const describePath = (path) => (path === "" ? "the item" : `"${path}"`);
+export const describePath = (path) => (path === "" ? "the item" : `"${path}"`);
 /** First path at which `matches` is true of the descriptor, walking into
  *  object subfields and a list's item, or null. */
-function findMatch(d, matches, path = "") {
+export function findMatch(d, matches, path = "") {
     if (matches(d))
         return path;
     if (d.type === "object") {
@@ -74,7 +98,13 @@ export const f = {
     file: () => builder({ type: "file" }),
     richtext: (opts) => builder({ type: "richtext", toolset: opts?.toolset ?? DEFAULT_TOOLSET }),
     dataAttributes: () => builder({ type: "dataAttributes" }),
-    select: (options) => builder({ type: "select", options: [...options] }),
+    boolean: () => builder({ type: "boolean" }),
+    /** One value from a list, shown as a dropdown. */
+    select: (options) => builder({ type: "select", options: normalizeOptions(options) }),
+    /** One value from a list, shown as a radio group. */
+    radio: (options) => builder({ type: "radio", options: normalizeOptions(options) }),
+    /** Several values from a list, stored as an array, shown as a checkbox list. */
+    checkboxes: (options) => builder({ type: "checkboxes", options: normalizeOptions(options) }),
     object: (shape) => {
         for (const [k, v] of Object.entries(shape))
             assertContainerItem("f.object", v.descriptor, k);

package/dist/image/SmoodlyImage.d.ts

@@ -14,5 +14,8 @@ export type SmoodlyImageProps = {
     alt?: string;
     loader?: ImageLoader;
     unoptimized?: boolean;
+} & {
+    /** Data attributes land on the wrapper box — a section's field mark (spec 2026-09-10 §1). */
+    [attr: `data-${string}`]: string | undefined;
 };
-export declare function SmoodlyImage({ image, aspect, sizes, priority, loading, className, style, alt, loader, unoptimized }: SmoodlyImageProps): ReactElement;
+export declare function SmoodlyImage({ image, aspect, sizes, priority, loading, className, style, alt, loader, unoptimized, ...data }: SmoodlyImageProps): ReactElement;

package/dist/image/SmoodlyImage.js

@@ -5,11 +5,11 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // site imports from the media layer. Server-safe — no "use client".
 import Image from "next/image";
 import { boxAspectOf, frameFor } from "./crop-math.js";
-export function SmoodlyImage({ image, aspect, sizes, priority, loading, className, style, alt, loader, unoptimized }) {
+export function SmoodlyImage({ image, aspect, sizes, priority, loading, className, style, alt, loader, unoptimized, ...data }) {
     const box = boxAspectOf(image, aspect);
     const frame = loader?.handlesCrop ? { left: 0, top: 0, width: 100, height: 100 } : frameFor(image, box);
     const svg = image.mime === "image/svg+xml";
-    return (_jsx("span", { className: className, style: { display: "block", position: "relative", overflow: "hidden", aspectRatio: String(box), ...style }, children: _jsx(Image, { src: image.url, alt: alt ?? image.alt, width: image.width, height: image.height, sizes: sizes, priority: priority, loading: loading, unoptimized: unoptimized ?? svg, ...(loader ? { loader: ({ width, quality }) => loader.url(image, { width, quality }) } : {}), style: {
+    return (_jsx("span", { className: className, ...data, style: { display: "block", position: "relative", overflow: "hidden", aspectRatio: String(box), ...style }, children: _jsx(Image, { src: image.url, alt: alt ?? image.alt, width: image.width, height: image.height, sizes: sizes, priority: priority, loading: loading, unoptimized: unoptimized ?? svg, ...(loader ? { loader: ({ width, quality }) => loader.url(image, { width, quality }) } : {}), style: {
                 position: "absolute", left: `${frame.left}%`, top: `${frame.top}%`,
                 width: `${frame.width}%`, height: `${frame.height}%`, maxWidth: "none",
             } }) }));

package/dist/index.d.ts

@@ -5,13 +5,17 @@ import { Section } from "./section-wrapper.tsx";
 import { page } from "./render.tsx";
 import { entryPage } from "./entry-page.tsx";
 import { shared } from "./shared.ts";
+import { marks } from "./marks.ts";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.tsx";
 export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageLink, PageViewProps } from "./render.tsx";
-export { RichText } from "./richtext-render.tsx";
+export { RichText, defaultRichTextImage } from "./richtext-render.tsx";
+export type { RichTextProps, RichTextElement, RichTextImageProps } from "./richtext-render.tsx";
 export type { PageSchema } from "./page.ts";
 export { fixedSlug } from "./page.ts";
 export type { EntryPageSchema, PairedEntryPage, EntryPageProps } from "./entry-page.tsx";
-export { f } from "./fields.ts";
+export { f, normalizeOptions, optionsOf, optionValues } from "./fields.ts";
+export { defaultsOf, withDefaults } from "./field-defaults.ts";
+export { filterPageTree } from "./page-tree.ts";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.ts";
 export type { Crop, Hotspot, AssetKind, ImageValue, VideoValue, FileValue, AssetMeta, AssetRecord, ResolvedImage, ResolvedVideo, ResolvedFile, } from "./media.ts";
 export { z } from "./zones.ts";
@@ -25,15 +29,17 @@ export { SupabasePageStore } from "./supabase-store.ts";
 export { SupabaseAssetStore } from "./supabase-asset-store.ts";
 export { collectEntryRefs, collectTreeRefs } from "./refs.ts";
 export type { RefEdge, SectionLike } from "./refs.ts";
+export { richtextBlocks, elementSchemas, IMAGE_NODE, ELEMENT_NODE } from "./richtext-walk.ts";
+export type { BlockNode, ElementSchemas, ImageNodeAttrs, ElementNodeAttrs } from "./richtext-walk.ts";
 export { MemoryRefIndex } from "./ref-index.ts";
 export { MemoryPathIndex } from "./path-index.ts";
 export type { PathIndex } from "./path-index.ts";
 export { MemoryEntryStore } from "./entry-store.ts";
 export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
-export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, } from "./entry-store.ts";
-export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.ts";
-export { affectedTargets, pageTag, entryTag, sharedTag } from "./revalidate.ts";
+export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.ts";
+export { affectedTargets, pageTag, entryTag, sharedTag, pagesTreeTag, collectionTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve.ts";
@@ -43,7 +49,7 @@ export { fixedPathFor } from "./localize.ts";
 export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
-export type { FieldBuilder, Descriptor, ValueOf } from "./fields.ts";
+export type { FieldBuilder, Descriptor, ValueOf, Option, OptionInput, OptionValue } from "./fields.ts";
 export type { SectionSchema, ElementSchema, BuilderMap } from "./schema.ts";
 export type { Props, PairedComponent } from "./pairing.tsx";
 export type { CollectionSchema, EntryOrder } from "./collections.ts";
@@ -126,9 +132,12 @@ export declare const smoodly: {
     toolset: typeof toolset;
     shared: typeof shared;
     Section: typeof Section;
+    marks: typeof marks;
 };
+export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.ts";
+export type { MarkNode, MarkPath, Marks, Scope } from "./marks.ts";
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.ts";
 export type { SmoodlyEnv } from "./env.ts";
 export { clientOptions, createSmoodlyClient } from "./client.ts";
 export { createSmoodlySite, pageContextOf } from "./site.ts";
-export type { SiteOptions, SitePage, SiteEntry, SiteHit, SmoodlySite, LoadOptions, PageTreeItem, SiteEntryItem, EntryTreeItem, EntryQuery, } from "./site.ts";
+export type { SiteOptions, SitePage, SitePageSchema, SiteEntry, SiteHit, SmoodlySite, LoadOptions, PageTreeItem, SiteEntryItem, EntryTreeItem, EntryQuery, } from "./site.ts";

package/dist/index.js

@@ -6,10 +6,13 @@ import { Section } from "./section-wrapper.js";
 import { page } from "./render.js";
 import { entryPage } from "./entry-page.js";
 import { shared } from "./shared.js";
+import { marks } from "./marks.js";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.js";
-export { RichText } from "./richtext-render.js";
+export { RichText, defaultRichTextImage } from "./richtext-render.js";
 export { fixedSlug } from "./page.js";
-export { f } from "./fields.js";
+export { f, normalizeOptions, optionsOf, optionValues } from "./fields.js";
+export { defaultsOf, withDefaults } from "./field-defaults.js";
+export { filterPageTree } from "./page-tree.js";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.js";
 export { z } from "./zones.js";
 export { defineConfig } from "./config.js";
@@ -20,13 +23,14 @@ export { imageDimensions } from "./image-dimensions.js";
 export { SupabasePageStore } from "./supabase-store.js";
 export { SupabaseAssetStore } from "./supabase-asset-store.js";
 export { collectEntryRefs, collectTreeRefs } from "./refs.js";
+export { richtextBlocks, elementSchemas, IMAGE_NODE, ELEMENT_NODE } from "./richtext-walk.js";
 export { MemoryRefIndex } from "./ref-index.js";
 export { MemoryPathIndex } from "./path-index.js";
 export { MemoryEntryStore } from "./entry-store.js";
 export { SupabaseEntryStore } from "./supabase-entry-store.js";
 export { SupabasePathIndex } from "./supabase-path-index.js";
-export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.js";
-export { affectedTargets, pageTag, entryTag, sharedTag } from "./revalidate.js";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.js";
+export { affectedTargets, pageTag, entryTag, sharedTag, pagesTreeTag, collectionTag } from "./revalidate.js";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
 export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.js";
 export { fixedPathFor } from "./localize.js";
@@ -46,7 +50,9 @@ export const smoodly = {
     toolset,
     shared,
     Section,
+    marks,
 };
+export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.js";
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.js";
 export { clientOptions, createSmoodlyClient } from "./client.js";
 export { createSmoodlySite, pageContextOf } from "./site.js";

package/dist/marks.d.ts

@@ -0,0 +1,53 @@
+import type { BuilderMap, NamespaceValues } from "./schema.ts";
+/** A section's root, from `<smoodly.Section>` in editor mode. */
+export declare const NODE_ATTR = "data-smd-node";
+/** An empty zone's placeholder box, from `<Zone>` in editor mode. */
+export declare const ZONE_ATTR = "data-smd-zone";
+export declare const EMPTY_ATTR = "data-smd-empty";
+/** The element that renders a field's value verbatim. */
+export declare const FIELD_ATTR = "data-smd-field";
+/** A list item's or object field's root: scopes the field names inside it. */
+export declare const ITEM_ATTR = "data-smd-item";
+/** The root of an inline editing session inside the canvas; the bridge
+ *  forwards nothing from inside it, and reports no marks under it. */
+export declare const EDITOR_ATTR = "data-smd-editor";
+/** What the resolver needs from an element — a DOM Element satisfies it. */
+export type MarkNode = {
+    getAttribute(name: string): string | null;
+    parentElement: MarkNode | null;
+};
+export type MarkPath = {
+    node: string;
+    path: string;
+};
+/** The section node and dotted field path of a marked element: its own
+ *  field name, prefixed by every item scope from the element itself up to
+ *  the section root. Null when the element carries no field mark or sits
+ *  outside a section node. */
+export declare function resolveMarkPath(el: MarkNode): MarkPath | null;
+type Keys<T> = Extract<keyof T, string>;
+type ElementOf<T> = NonNullable<T> extends readonly (infer E)[] ? E : never;
+/** The helpers for one level of a section's values: the section itself,
+ *  a list item, or an object field. Item attributes are relative to the
+ *  parent scope — the resolver joins them — so the helpers carry no path. */
+export type Marks<T> = {
+    /** Spread on the element that renders `key` verbatim. */
+    field<K extends Keys<T>>(key: K): {
+        "data-smd-field": K;
+    };
+    /** List item `index` of `key`: spread `.attrs` on the item's root and mark the fields inside with the returned helpers. */
+    item<K extends Keys<T>>(key: K, index: number): Scope<ElementOf<T[K]>>;
+    /** The object field `key`: spread `.attrs` on its root and mark the fields inside. */
+    object<K extends Keys<T>>(key: K): Scope<NonNullable<T[K]>>;
+};
+export type Scope<T> = Marks<T> & {
+    attrs: {
+        "data-smd-item": string;
+    };
+};
+/** Typed marks for a section or element schema: `const m = smoodly.marks(heroSchema)`,
+ *  then `<h1 {...m.field("heading")}>`. The raw attributes stay the contract. */
+export declare function marks<S extends {
+    __f?: BuilderMap;
+}>(_schema: S): Marks<NamespaceValues<NonNullable<S["__f"]>>>;
+export {};

package/dist/marks.js

@@ -0,0 +1,43 @@
+/** A section's root, from `<smoodly.Section>` in editor mode. */
+export const NODE_ATTR = "data-smd-node";
+/** An empty zone's placeholder box, from `<Zone>` in editor mode. */
+export const ZONE_ATTR = "data-smd-zone";
+export const EMPTY_ATTR = "data-smd-empty";
+/** The element that renders a field's value verbatim. */
+export const FIELD_ATTR = "data-smd-field";
+/** A list item's or object field's root: scopes the field names inside it. */
+export const ITEM_ATTR = "data-smd-item";
+/** The root of an inline editing session inside the canvas; the bridge
+ *  forwards nothing from inside it, and reports no marks under it. */
+export const EDITOR_ATTR = "data-smd-editor";
+/** The section node and dotted field path of a marked element: its own
+ *  field name, prefixed by every item scope from the element itself up to
+ *  the section root. Null when the element carries no field mark or sits
+ *  outside a section node. */
+export function resolveMarkPath(el) {
+    const field = el.getAttribute(FIELD_ATTR);
+    if (!field)
+        return null;
+    const segments = [field];
+    for (let cur = el; cur; cur = cur.parentElement) {
+        const node = cur.getAttribute(NODE_ATTR);
+        if (node)
+            return { node, path: segments.join(".") };
+        const item = cur.getAttribute(ITEM_ATTR);
+        if (item)
+            segments.unshift(item);
+    }
+    return null;
+}
+function level() {
+    return {
+        field: (key) => ({ [FIELD_ATTR]: key }),
+        item: (key, index) => ({ ...level(), attrs: { [ITEM_ATTR]: `${key}.${index}` } }),
+        object: (key) => ({ ...level(), attrs: { [ITEM_ATTR]: key } }),
+    };
+}
+/** Typed marks for a section or element schema: `const m = smoodly.marks(heroSchema)`,
+ *  then `<h1 {...m.field("heading")}>`. The raw attributes stay the contract. */
+export function marks(_schema) {
+    return level();
+}

package/dist/media.d.ts

@@ -1,4 +1,5 @@
 import type { Descriptor } from "./fields.ts";
+import { type ElementSchemas } from "./richtext-walk.ts";
 export type Crop = {
     left: number;
     top: number;
@@ -102,7 +103,7 @@ export declare const isMediaValue: (v: unknown) => v is {
 };
 /** Every asset id a value set references, walking lists and objects —
  *  unlike refs, media may sit inside a container (spec §8). */
-export declare function collectAssetIds(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, out: Set<string>): void;
+export declare function collectAssetIds(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, out: Set<string>, elements?: ElementSchemas): void;
 /** Replace every media value in place with its resolved object — or delete
  *  it when the asset is missing or pending, so `image?.url` guards hold. */
-export declare function applyAssets(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, assets: Map<string, AssetRecord>): void;
+export declare function applyAssets(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, assets: Map<string, AssetRecord>, elements?: ElementSchemas): void;

package/dist/media.js

@@ -1,3 +1,4 @@
+import { ELEMENT_NODE, IMAGE_NODE, elementOf, elementSets, richtextBlocks } from "./richtext-walk.js";
 /** The refs target collection of every asset edge — a reserved registered name. */
 export const ASSET_COLLECTION = "asset";
 export const MEDIA_TYPES = new Set(["image", "video", "file"]);
@@ -30,7 +31,7 @@ export const cropAspect = (crop, imageAspect) => (crop.width * imageAspect) / cr
 export const isMediaValue = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && typeof v.asset === "string";
 /** Every asset id a value set references, walking lists and objects —
  *  unlike refs, media may sit inside a container (spec §8). */
-export function collectAssetIds(values, descriptors, out) {
+export function collectAssetIds(values, descriptors, out, elements = {}) {
     if (!values)
         return;
     for (const [key, d] of Object.entries(descriptors)) {
@@ -41,8 +42,24 @@ export function collectAssetIds(values, descriptors, out) {
             if (isMediaValue(value))
                 out.add(value.asset);
         }
+        else if (d.type === "richtext") {
+            // Block nodes (spec 2026-09-08 block nodes §2): image nodes, and media inside a known element's fields and styles.
+            for (const node of richtextBlocks(value)) {
+                if (node.type === IMAGE_NODE) {
+                    const image = node.attrs.image;
+                    if (isMediaValue(image))
+                        out.add(image.asset);
+                }
+                else if (node.type === ELEMENT_NODE) {
+                    const schema = elementOf(node, elements);
+                    if (schema)
+                        for (const set of elementSets(node, schema))
+                            collectAssetIds(set.values, set.descriptors, out, elements);
+                }
+            }
+        }
         else if (d.type === "object" && typeof value === "object" && !Array.isArray(value)) {
-            collectAssetIds(value, d.fields, out);
+            collectAssetIds(value, d.fields, out, elements);
         }
         else if (d.type === "list" && Array.isArray(value)) {
             const item = d.item;
@@ -52,7 +69,10 @@ export function collectAssetIds(values, descriptors, out) {
                         out.add(v.asset);
                 }
                 else if (item.type === "object" && v && typeof v === "object") {
-                    collectAssetIds(v, item.fields, out);
+                    collectAssetIds(v, item.fields, out, elements);
+                }
+                else if (item.type === "richtext") {
+                    collectAssetIds({ v }, { v: item }, out, elements);
                 }
             }
         }
@@ -97,7 +117,7 @@ function resolveOne(value, d, assets) {
 }
 /** Replace every media value in place with its resolved object — or delete
  *  it when the asset is missing or pending, so `image?.url` guards hold. */
-export function applyAssets(values, descriptors, assets) {
+export function applyAssets(values, descriptors, assets, elements = {}) {
     if (!values)
         return;
     for (const [key, d] of Object.entries(descriptors)) {
@@ -111,8 +131,25 @@ export function applyAssets(values, descriptors, assets) {
             else
                 values[key] = resolved;
         }
+        else if (d.type === "richtext") {
+            for (const node of richtextBlocks(value)) {
+                if (node.type === IMAGE_NODE) {
+                    const resolved = resolveOne(node.attrs.image, { type: "image" }, assets);
+                    if (resolved === undefined)
+                        delete node.attrs.image;
+                    else
+                        node.attrs.image = resolved;
+                }
+                else if (node.type === ELEMENT_NODE) {
+                    const schema = elementOf(node, elements);
+                    if (schema)
+                        for (const set of elementSets(node, schema))
+                            applyAssets(set.values, set.descriptors, assets, elements);
+                }
+            }
+        }
         else if (d.type === "object" && typeof value === "object" && !Array.isArray(value)) {
-            applyAssets(value, d.fields, assets);
+            applyAssets(value, d.fields, assets, elements);
         }
         else if (d.type === "list" && Array.isArray(value)) {
             const item = d.item;
@@ -122,7 +159,12 @@ export function applyAssets(values, descriptors, assets) {
             else if (item.type === "object") {
                 for (const v of value)
                     if (v && typeof v === "object")
-                        applyAssets(v, item.fields, assets);
+                        applyAssets(v, item.fields, assets, elements);
+            }
+            else if (item.type === "richtext") {
+                // Resolves in place inside the document object `v`; the wrapper is throwaway.
+                for (const v of value)
+                    applyAssets({ v }, { v: item }, assets, elements);
             }
         }
     }

package/dist/next/index.d.ts

@@ -1,3 +1,5 @@
 export { createPageRenderer } from "./page-renderer.tsx";
 export type { PageRendererOptions, PathRenderOptions, PageRegistration } from "./page-renderer.tsx";
 export { metadataFrom } from "./meta.ts";
+export { createSmoodlyQueries } from "./queries.ts";
+export type { SmoodlyQueries, QueryOptions, EntriesQuery, TypedEntryItem, SharedValue } from "./queries.ts";

package/dist/next/index.js

@@ -1,2 +1,3 @@
 export { createPageRenderer } from "./page-renderer.js";
 export { metadataFrom } from "./meta.js";
+export { createSmoodlyQueries } from "./queries.js";

package/dist/next/meta.d.ts

@@ -1,4 +1,8 @@
 import type { Metadata } from "next";
-/** Maps the page tree's meta bag onto Next metadata. Absent meta returns
- * {} so the app's own layout.tsx defaults apply untouched. */
-export declare function metadataFrom(meta: unknown): Metadata;
+/** Maps the page tree's meta onto Next metadata (spec 2026-09-10 page
+ * fields §4). The SEO title falls back to the page's own title so every
+ * page carries one; absent meta and no title returns {} so the app's
+ * layout.tsx defaults apply untouched. */
+export declare function metadataFrom(meta: unknown, page?: {
+    title?: string;
+}): Metadata;

package/dist/next/meta.js

@@ -1,13 +1,15 @@
-/** Maps the page tree's meta bag onto Next metadata. Absent meta returns
- * {} so the app's own layout.tsx defaults apply untouched. */
-export function metadataFrom(meta) {
-    if (typeof meta !== "object" || meta === null || Array.isArray(meta))
-        return {};
-    const m = meta;
+import { imageUrl } from "../image/loaders.js";
+const isResolvedImage = (v) => typeof v === "object" && v !== null && typeof v.url === "string";
+/** Maps the page tree's meta onto Next metadata (spec 2026-09-10 page
+ * fields §4). The SEO title falls back to the page's own title so every
+ * page carries one; absent meta and no title returns {} so the app's
+ * layout.tsx defaults apply untouched. */
+export function metadataFrom(meta, page) {
+    const m = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
     const str = (key) => (typeof m[key] === "string" && m[key] ? m[key] : undefined);
-    const title = str("title");
+    const title = str("title") ?? (page?.title ? page.title : undefined);
     const description = str("description");
-    const ogImage = str("ogImage");
+    const ogImage = m.ogImage;
     const out = {};
     if (title)
         out.title = title;
@@ -18,9 +20,16 @@ export function metadataFrom(meta) {
         og.title = title;
     if (description)
         og.description = description;
-    if (ogImage)
+    if (isResolvedImage(ogImage)) {
+        // The delivery seam decides the URL; the cloud's transform loader (OQ 28) can serve a real 1200-wide render.
+        og.images = [{ url: imageUrl(ogImage, { width: 1200 }), width: ogImage.width, height: ogImage.height, ...(ogImage.alt ? { alt: ogImage.alt } : {}) }];
+    }
+    else if (typeof ogImage === "string" && ogImage) {
         og.images = [ogImage];
+    }
     if (Object.keys(og).length > 0)
         out.openGraph = og;
+    if (m.noindex === true)
+        out.robots = { index: false, follow: false };
     return out;
 }

package/dist/next/page-renderer.js

@@ -73,7 +73,7 @@ export function createPageRenderer(options) {
         const hit = await load(locale, path, draft);
         if (!hit || !accept(hit))
             return {};
-        return { ...(hit.kind === "page" ? metadataFrom(hit.tree.meta) : {}), ...alternates(hit) };
+        return { ...(hit.kind === "page" ? metadataFrom(hit.tree.meta, { title: hit.title }) : {}), ...alternates(hit) };
     }
     const any = () => true;
     /** The escape hatch may only render ITS OWN registration's record. */

package/dist/next/queries.d.ts

@@ -0,0 +1,36 @@
+import type { CollectionSchema } from "../collections.ts";
+import type { EntryRecord } from "../entry-store.ts";
+import type { SharedSchema } from "../shared.ts";
+import type { EntryQuery, PageTreeItem, SiteEntryItem, SitePage, SmoodlySite } from "../site.ts";
+export type QueryOptions = {
+    locale?: string;
+};
+export type EntriesQuery = Omit<EntryQuery, "locale" | "draft"> & QueryOptions;
+type ByName<T, N> = Extract<T, {
+    name: N;
+}>;
+/** Fields typed from the schema; a widened `CollectionSchema[]` array (names are `string`) falls back to the untyped record instead of `never`. */
+type EntryFields<C extends readonly CollectionSchema<any, string>[], N> = string extends C[number]["name"] ? Record<string, unknown> : NonNullable<ByName<C[number], N>["__entry"]>;
+/** A list item whose `entry.fields` are the collection's typed values. */
+export type TypedEntryItem<C extends readonly CollectionSchema<any, string>[], N> = Omit<SiteEntryItem, "entry"> & {
+    entry: Omit<EntryRecord, "fields"> & {
+        fields: EntryFields<C, N>;
+    };
+};
+export type SharedValue<S extends readonly SharedSchema<any, string>[], N> = string extends S[number]["name"] ? Record<string, unknown> : NonNullable<ByName<S[number], N>["__value"]>;
+export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S extends readonly SharedSchema<any, string>[]> = {
+    /** The published page tree in a locale, every item with its page fields. */
+    getPageTree(options?: QueryOptions): Promise<PageTreeItem[]>;
+    /** A page by locale-relative path ("/company/about-us") or id. */
+    getPage(pathOrId: string, options?: QueryOptions): Promise<SitePage | null>;
+    /** Published entries of a collection: `where` (shared fields), `order`, `limit`, `parent` run in the store. */
+    getEntries<N extends C[number]["name"]>(collection: N, options?: EntriesQuery): Promise<TypedEntryItem<C, N>[]>;
+    getEntry<N extends C[number]["name"]>(collection: N, idOrPath: string, options?: QueryOptions): Promise<TypedEntryItem<C, N> | null>;
+    getShared<N extends S[number]["name"]>(item: N, options?: QueryOptions): Promise<SharedValue<S, N> | null>;
+};
+export declare function createSmoodlyQueries<const C extends readonly CollectionSchema<any, string>[], const S extends readonly SharedSchema<any, string>[] = []>(options: {
+    site: SmoodlySite;
+    collections: C;
+    shared?: S;
+}): SmoodlyQueries<C, S>;
+export {};