smoodly 0.0.13 → 0.0.15

package/dist/admin/serialize.js

@@ -69,6 +69,8 @@ export function serializeAdminConfig(config) {
                 ...(slug !== undefined ? { slug } : {}),
                 ...(typeof p.slug === "object" && p.slug !== null ? { slugs: { ...p.slug } } : {}),
                 zones: p.zones ?? {},
+                fields: serializeMap(p.fields),
+                seo: p.meta?.seo === true,
             };
         }),
         shared: (config.registry.shared ?? []).map((s) => ({

package/dist/admin/tree-ops.d.ts

@@ -32,3 +32,5 @@ export declare function nodeFromSample(section: Pick<AdminSection, "name" | "fie
  * schema. Returns the same tree when nothing changed. */
 export declare function fillLockedZones(tree: PageTree, policies: Record<string, ZonePolicy>, sections: AdminSection[], sharedIds?: Record<string, string>): PageTree;
 export declare function newNodeId(type: string): string;
+/** A page-level value — the template's page fields or the SEO meta (spec 2026-09-10 page fields §5). */
+export declare function patchPage(tree: PageTree, ns: "fields" | "meta", key: string, value: unknown): PageTree;

package/dist/admin/tree-ops.js

@@ -116,7 +116,7 @@ export function nodeFromSample(section, id) {
     const fields = {};
     const styles = {};
     for (const [key, d] of Object.entries(section.fields)) {
-        const sampled = section.sample?.[key];
+        const sampled = section.sample?.[key] ?? d.default ?? (d.type === "boolean" ? false : undefined);
         if (sampled !== undefined)
             fields[key] = sampled;
         else if (ABSENT_WHEN_UNSAMPLED.has(d.type))
@@ -168,3 +168,7 @@ export function fillLockedZones(tree, policies, sections, sharedIds = {}) {
 export function newNodeId(type) {
     return `${type}-${crypto.randomUUID().slice(0, 8)}`;
 }
+/** A page-level value — the template's page fields or the SEO meta (spec 2026-09-10 page fields §5). */
+export function patchPage(tree, ns, key, value) {
+    return { ...tree, [ns]: { ...(tree[ns] ?? {}), [key]: value } };
+}

package/dist/admin/ui/primitives.d.ts

@@ -27,6 +27,15 @@ export declare function IconButton({ label, tone, size, children, ...rest }: {
     size?: number;
     children: ReactNode;
 } & ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+/** An on/off control in the design system's control language: a pill
+ *  track, a knob, the accent when on. A button, so it sits inside a
+ *  field's implicit label and the label click toggles it. */
+export declare function Switch({ checked, onChange, disabled, label }: {
+    checked: boolean;
+    onChange(next: boolean): void;
+    disabled?: boolean;
+    label?: string;
+}): import("react").JSX.Element;
 /** The drag handle every sortable row carries at its left edge (spec
  *  2026-09-09 §2): a button, so it is focusable and takes the arrow keys;
  *  `touch-action: none` (theme) so a finger on it drags instead of scrolling. */

package/dist/admin/ui/primitives.js

@@ -51,6 +51,12 @@ export function LinkButton({ variant = "secondary", children, ...rest }) {
 export function IconButton({ label, tone = "default", size = 24, children, ...rest }) {
     return (_jsx("button", { type: "button", "aria-label": label, title: label, className: cx("sm-iconbtn", tone === "inverse" && "sm-iconbtn--inverse"), style: { width: size, height: size }, ...rest, children: children }));
 }
+/** An on/off control in the design system's control language: a pill
+ *  track, a knob, the accent when on. A button, so it sits inside a
+ *  field's implicit label and the label click toggles it. */
+export function Switch({ checked, onChange, disabled, label }) {
+    return (_jsx("button", { type: "button", role: "switch", "aria-checked": checked, "aria-label": label, disabled: disabled, className: "sm-switch", onClick: () => onChange(!checked), children: _jsx("span", { className: "sm-switch__knob" }) }));
+}
 /** The drag handle every sortable row carries at its left edge (spec
  *  2026-09-09 §2): a button, so it is focusable and takes the arrow keys;
  *  `touch-action: none` (theme) so a finger on it drags instead of scrolling. */

package/dist/admin/ui/resize.d.ts

@@ -3,7 +3,7 @@ export declare const INSPECTOR_W_KEY = "smoodly-inspector-w";
 /** Below this the richtext toolbar and the outline rows no longer fit. */
 export declare const MIN_INSPECTOR_W = 260;
 /** The token's value in the warm look; what a reset returns to. */
-export declare const DEFAULT_INSPECTOR_W = 320;
+export declare const DEFAULT_INSPECTOR_W = 360;
 /** One arrow-key press. */
 export declare const RESIZE_STEP = 16;
 /** Half the editor row (canvas + handle + inspector), never below the minimum. */

package/dist/admin/ui/resize.js

@@ -5,7 +5,7 @@ export const INSPECTOR_W_KEY = "smoodly-inspector-w";
 /** Below this the richtext toolbar and the outline rows no longer fit. */
 export const MIN_INSPECTOR_W = 260;
 /** The token's value in the warm look; what a reset returns to. */
-export const DEFAULT_INSPECTOR_W = 320;
+export const DEFAULT_INSPECTOR_W = 360;
 /** One arrow-key press. */
 export const RESIZE_STEP = 16;
 /** Half the editor row (canvas + handle + inspector), never below the minimum. */

package/dist/admin/ui/theme.js

@@ -101,7 +101,7 @@ const SCALE = `
   --control-h:40px; --control-h-sm:34px; --control-h-lg:48px; --button-h:36px; --row-h:48px; --topbar-h:64px;
   --outline-row-h:36px; --seg-pad-y:7px; --tabs-pad:3px;
   --plus-h:32px; --plus-pad:0 14px 0 6px; --plus-label:inline;
-  --nav-w:72px; --inspector-w:320px; --gutter:20px; --frame-pad:24px;
+  --nav-w:72px; --inspector-w:360px; --gutter:20px; --frame-pad:24px;
   --rail-pad:22px 6px 16px; --rail-logo:none; --topbar-pad:0; --back-size:32px; --back-bg:var(--surface);
   --table-pad:8px 12px; --table-top:80px; --canvas-pad:24px 40px 0; --card-pad:16px 18px; --card-gap:12px; --form-pad:32px 40px;
   --border:1px solid var(--line);
@@ -637,6 +637,21 @@ body:has(.sm-admin){margin:0}
 .sm-seg__opt[aria-pressed="true"]{background:var(--surface);color:var(--text);font-weight:600;box-shadow:var(--shadow-seg)}
 /* A locale the record does not have yet: subtle, still a button (it opens the add pane). */
 .sm-seg__opt--absent{color:var(--text-subtle)}
+/* Switch (f.boolean, the SEO noindex toggle): a pill track, knob slides right when on. */
+.sm-switch{width:36px;height:20px;padding:2px;border:0;border-radius:var(--radius-round);background:var(--seg-bg);cursor:pointer;display:inline-flex;align-items:center;flex:none}
+.sm-switch[aria-checked="true"]{background:var(--accent)}
+.sm-switch__knob{width:16px;height:16px;border-radius:50%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.25);transition:transform .15s}
+.sm-switch[aria-checked="true"] .sm-switch__knob{transform:translateX(16px)}
+.sm-switch:disabled{opacity:.6;cursor:default}
+.sm-switch:focus-visible{box-shadow:var(--focus-ring)}
+/* Radio groups and checkbox lists (f.radio, f.checkboxes): native inputs in the accent, one row per option. */
+.sm-choices{display:flex;flex-direction:column;gap:8px;padding:4px 0}
+.sm-choice{display:flex;align-items:center;gap:8px;font-size:var(--text-md);cursor:pointer}
+.sm-choice input{accent-color:var(--accent);width:16px;height:16px;margin:0;flex:none}
+/* A soft counter past its limit (SEO title and description). */
+.sm-counter--over{color:var(--warn)}
+/* The page glyph beside the page title in the empty-selection inspector head. */
+.sm-pageglyph{width:10px;height:13px;border:1.5px solid var(--text-muted);border-radius:var(--radius-xs);flex:none}
 .sm-divider{height:1px;background:var(--line);flex:none}
 .sm-sectionlabel{display:flex;align-items:center;justify-content:space-between;gap:8px}
 .sm-sectionlabel--mono>.sm-label{

package/dist/admin/validate.js

@@ -2,6 +2,7 @@
 // lives admin/server-side). Entry saves validate; page drafts do NOT
 // (drafts must save freely) — publish validates every node. Objects and
 // lists recurse; error paths are dotted (`cta.href`, `points.2.heading`).
+import { optionValues } from "../fields.js";
 import { hasContent } from "./richtext-doc.js";
 import { ELEMENT_NODE, richtextBlocks } from "../richtext-walk.js";
 const subfields = (d) => d.fields && typeof d.fields === "object" ? d.fields : {};
@@ -9,7 +10,7 @@ const itemOf = (d) => d.item && typeof d.item === "object" ? d.item : undefined;
 const isEmpty = (v) => v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0);
 /** An object whose every subfield is optional — or is itself an object that
  *  may be absent — may be absent altogether. */
-const mayBeAbsent = (d) => d.optional === true || (d.type === "object" && Object.values(subfields(d)).every(mayBeAbsent));
+const mayBeAbsent = (d) => d.optional === true || d.type === "boolean" || (d.type === "object" && Object.values(subfields(d)).every(mayBeAbsent));
 const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function validateValue(path, value, d, errors, elements) {
     if (isEmpty(value)) {
@@ -69,8 +70,28 @@ function validateValue(path, value, d, errors, elements) {
             validateValue(`${path}.${k}`, value[k], sub, errors, elements);
         return;
     }
-    if (d.type === "select" && Array.isArray(d.options) && !d.options.includes(value)) {
-        errors.push({ field: path, message: `Must be one of: ${d.options.join(", ")}.` });
+    if (d.type === "boolean") {
+        if (typeof value !== "boolean")
+            errors.push({ field: path, message: "Must be on or off." });
+        return;
+    }
+    if (d.type === "select" || d.type === "radio") {
+        const allowed = optionValues(d.options);
+        if (allowed.length > 0 && !allowed.includes(value)) {
+            errors.push({ field: path, message: `Must be one of: ${allowed.join(", ")}.` });
+        }
+        return;
+    }
+    if (d.type === "checkboxes") {
+        if (!Array.isArray(value)) {
+            errors.push({ field: path, message: "Must be a list." });
+            return;
+        }
+        const allowed = optionValues(d.options);
+        if (value.some((v) => !allowed.includes(v))) {
+            errors.push({ field: path, message: `Must be one of: ${allowed.join(", ")}.` });
+        }
+        return;
     }
     if (typeof d.max === "number" && typeof value === "string" && value.length > d.max) {
         errors.push({ field: path, message: `Must be at most ${d.max} characters.` });

package/dist/collections.d.ts

@@ -8,12 +8,13 @@ export type EntryOrder = "manual" | {
 };
 export declare const DEFAULT_ORDER: EntryOrder;
 export declare const BUILT_IN_ORDER_FIELDS: readonly ["createdAt", "updatedAt"];
-export type CollectionSchema<F extends BuilderMap = BuilderMap> = {
+export type CollectionSchema<F extends BuilderMap = BuilderMap, N extends string = string> = {
     /** "shared" marks a code-declared singleton (spec 2026-09-07 decision
      *  4): a shared item IS a collection with one entry, so both entry
      *  stores accept it in the same list and branch on this. */
     kind: "collection" | "shared";
-    name: string;
+    /** Literal when declared inline (spec 2026-09-11 §6), so a queries object can check names. */
+    name: N;
     title: string;
     titleField?: string;
     fields: Record<string, Descriptor>;
@@ -38,8 +39,8 @@ export type CollectionSchema<F extends BuilderMap = BuilderMap> = {
 };
 export declare const collectionOrder: (c: CollectionSchema<any>) => EntryOrder;
 export declare const collectionDepth: (c: CollectionSchema<any>) => number;
-export declare function collection<F extends BuilderMap>(input: {
-    name: string;
+export declare function collection<F extends BuilderMap, const N extends string = string>(input: {
+    name: N;
     title: string;
     titleField?: string;
     fields: F;
@@ -52,4 +53,4 @@ export declare function collection<F extends BuilderMap>(input: {
         listColumns?: string[];
     };
     versions?: boolean;
-}): CollectionSchema<F>;
+}): CollectionSchema<F, N>;

package/dist/entry-store.d.ts

@@ -39,10 +39,27 @@ export type EntryUsage = {
     sourceId: string;
     sourceField: string;
 };
+export type WhereValue = string | number | boolean;
+/** Equality (scalar) or any-of (array) on top-level SHARED fields (spec 2026-09-11 §3). */
+export type Where = Record<string, WhereValue | WhereValue[]>;
+/** The field types whose value is an array: a scalar `where` on one is
+ *  containment, and any-of on one is refused by the site layer (both
+ *  adapters read the text form of the whole array, never its elements). */
+export declare const ARRAY_FIELD_TYPES: ReadonlySet<string>;
+/** The memory adapter's and the tests' reading of `where`: a scalar matches an
+ *  equal value or an array holding it (JSONB containment); an array is any-of,
+ *  compared as text like PostgREST's `->>`. */
+export declare function matchesWhere(fields: Record<string, unknown>, where: Where): boolean;
 export type ListOptions = {
+    /** Equality / any-of on shared fields, executed by the store (spec 2026-09-11 §3). */
+    where?: Where;
+    /** Applied after order and after the `status` filter. */
+    limit?: number;
     /** Absent = the collection's configured order (config); `"manual"` sorts by `sort` asc. */
     order?: EntryOrder;
-    /** With `status`: the locale whose row is inspected; the default locale when omitted. */
+    /** Alone: only entries PRESENT in this locale (spec 2026-09-11 §3, so `limit`
+     *  counts rows that are there). With `status`: the locale whose row is
+     *  inspected; the default locale when only `status` is given. */
     locale?: string;
     /** Only entries whose row in `locale` is published. */
     status?: "published";

package/dist/entry-store.js

@@ -16,6 +16,24 @@ import { MemoryPathIndex } from "./path-index.js";
 import { sharedEntryId } from "./shared-id.js";
 import { DEFAULT_SPACE_ID } from "./sql-space.js";
 import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, } from "./paths.js";
+/** The field types whose value is an array: a scalar `where` on one is
+ *  containment, and any-of on one is refused by the site layer (both
+ *  adapters read the text form of the whole array, never its elements). */
+export const ARRAY_FIELD_TYPES = new Set(["checkboxes", "refList", "list"]);
+/** PostgREST's `->>`: a scalar's text, an array's or object's JSON text (Postgres
+ *  spaces an object's text differently, but no scalar equals either form). */
+const textForm = (value) => (value !== null && typeof value === "object" ? JSON.stringify(value) : String(value));
+/** The memory adapter's and the tests' reading of `where`: a scalar matches an
+ *  equal value or an array holding it (JSONB containment); an array is any-of,
+ *  compared as text like PostgREST's `->>`. */
+export function matchesWhere(fields, where) {
+    return Object.entries(where).every(([key, want]) => {
+        const have = fields[key];
+        if (Array.isArray(want))
+            return want.some((w) => String(w) === textForm(have));
+        return Array.isArray(have) ? have.includes(want) : have === want;
+    });
+}
 export function schemaOf(collections, name) {
     const schema = collections.find((c) => c.name === name);
     if (!schema)
@@ -307,13 +325,20 @@ export class MemoryEntryStore {
     async list(collection, options) {
         const schema = this.schema(collection);
         let rows = [...this.entries.values()].filter((e) => e.collection === collection);
-        if (options?.status) {
+        if (options?.status || options?.locale !== undefined) {
             const locale = options.locale ?? this.locales.default;
-            rows = rows.filter((e) => e.locales[locale]?.status === options.status);
+            rows = rows.filter((e) => {
+                const row = e.locales[locale];
+                return row !== undefined && (!options.status || row.status === options.status);
+            });
         }
         if (options?.parent !== undefined)
             rows = rows.filter((e) => e.parentId === options.parent);
+        if (options?.where)
+            rows = rows.filter((e) => matchesWhere(e.fields, options.where));
         rows.sort(compareEntries(options?.order ?? collectionOrder(schema), (e) => this.order.get(e.id)));
+        if (typeof options?.limit === "number")
+            rows = rows.slice(0, options.limit);
         return rows.map((e) => this.snapshot(e));
     }
     async getMany(collection, ids, locale, options) {

package/dist/field-defaults.d.ts

@@ -0,0 +1,8 @@
+type Defaultable = {
+    type?: string;
+    default?: unknown;
+};
+export declare function defaultsOf(descriptors: Record<string, Defaultable>): Record<string, unknown>;
+/** `values` with every absent key filled from the descriptors' defaults; a new object. */
+export declare function withDefaults(values: Record<string, unknown> | undefined, descriptors: Record<string, Defaultable>): Record<string, unknown>;
+export {};

package/dist/field-defaults.js

@@ -0,0 +1,18 @@
+export function defaultsOf(descriptors) {
+    const out = {};
+    for (const [key, d] of Object.entries(descriptors)) {
+        if (d.default !== undefined)
+            out[key] = d.default;
+        else if (d.type === "boolean")
+            out[key] = false;
+    }
+    return out;
+}
+/** `values` with every absent key filled from the descriptors' defaults; a new object. */
+export function withDefaults(values, descriptors) {
+    const out = defaultsOf(descriptors);
+    for (const [key, v] of Object.entries(values ?? {}))
+        if (v !== undefined)
+            out[key] = v;
+    return out;
+}

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 & {
@@ -65,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 {
@@ -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/index.d.ts

@@ -13,7 +13,9 @@ export type { RichTextProps, RichTextElement, RichTextImageProps } from "./richt
 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";
@@ -35,9 +37,9 @@ 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";
@@ -47,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";
@@ -138,4 +140,4 @@ 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

@@ -10,7 +10,9 @@ import { marks } from "./marks.js";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./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";
@@ -27,8 +29,8 @@ 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";

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