smoodly 0.0.55 → 0.0.56

package/dist/admin/forms/FieldWidget.js

@@ -10,6 +10,7 @@ import { DatePicker } from "./DatePicker.js";
 import { optionsOf } from "../../fields.js";
 import { isHidden } from "../../conditions.js";
 import { cssProblem } from "../../css.js";
+import { linkProblem } from "../validate.js";
 import { Button, Field, Switch } from "../ui/primitives.js";
 import { fieldLabel } from "../field-label.js";
 import { patchObject } from "./list.js";
@@ -22,6 +23,8 @@ export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors,
     const message = errors?.[path] ?? (below ? errors?.[below] : undefined);
     // The descriptor's default shows while the value is absent (spec 2026-09-10 page fields §1).
     const value = valueProp === undefined && d.default !== undefined ? d.default : valueProp;
+    // A link the site would not render is marked as it is typed; publish refuses it with the same words.
+    const problem = d.type === "link" ? linkProblem(value) : null;
     // The custom section's rows (spec 2026-09-14 §6): the row cards instead of the generic list.
     if (d.widget === "rows") {
         const rows = _jsx(RowsWidget, { descriptor: d, value: value, onChange: onChange, errors: errors, path: path, inlinePath: inlinePath, onEditHere: onEditHere });
@@ -146,7 +149,7 @@ export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors,
     // A <label> activates its first labelable descendant, so it may only wrap a
     // single control — around refList's rows, an object's fieldset or a list's
     // rows it would turn every click into a press of the first button.
-    return (_jsx(Field, { label: label(fieldKey), mark: mark, counter: counter, hint: hint, error: message, asDiv: asDiv, path: path, children: control }));
+    return (_jsx(Field, { label: label(fieldKey), mark: mark, counter: counter, hint: hint, error: message ?? problem ?? undefined, asDiv: asDiv, path: path, children: control }));
 }
 /** The richtext field while it is edited in the canvas (spec 2026-09-10 §5). */
 export function InlineNote({ onEditHere }) {

package/dist/admin/tree-ops.js

@@ -1,5 +1,6 @@
 import { GLOBAL_NODE_TYPE } from "../global.js";
 import { setAtPath, unsetAtPath } from "./field-paths.js";
+import { optionsOf } from "../fields.js";
 export function zoneOf(tree, id) {
     for (const [zone, nodes] of Object.entries(tree.zones)) {
         if (nodes.some((n) => n.id === id))
@@ -123,12 +124,15 @@ const EMPTY_BY_TYPE = { refList: [], object: {} };
  * broken-image icon or a stray zero, worse than nothing at all. With no
  * sample, leave the key out of `fields` entirely rather than seed a lie. */
 const ABSENT_WHEN_UNSAMPLED = new Set(["image", "video", "file", "number"]);
+/** A required choice shows its first option (FieldWidget renders no blank one), so a new node stores it too — as a
+ *  list item does (forms/list.ts) — and publish never says Required for a choice the editor sees made. */
+const firstChoice = (d) => (d.type === "select" || d.type === "radio") && d.optional !== true ? optionsOf(d.options)[0]?.value : undefined;
 /** Also fills an element node (an `AdminElement` is a section shape plus contexts). Never seeds `styles` or `css`: Default stores nothing (spec 2026-09-14 §2). */
 export function nodeFromSample(section, id) {
     const fields = {};
     const settings = {};
     for (const [key, d] of Object.entries(section.fields)) {
-        const sampled = section.sample?.[key] ?? d.default ?? (d.type === "boolean" ? false : undefined);
+        const sampled = section.sample?.[key] ?? d.default ?? firstChoice(d) ?? (d.type === "boolean" ? false : undefined);
         if (sampled !== undefined)
             fields[key] = sampled;
         else if (ABSENT_WHEN_UNSAMPLED.has(d.type))
@@ -140,7 +144,7 @@ export function nodeFromSample(section, id) {
             fields[key] = EMPTY_BY_TYPE[d.type] ?? "";
     }
     for (const [key, d] of Object.entries(section.settings)) {
-        const v = section.sample?.[key] ?? d.default;
+        const v = section.sample?.[key] ?? d.default ?? firstChoice(d);
         if (v !== undefined)
             settings[key] = v;
     }

package/dist/admin/validate.d.ts

@@ -19,6 +19,10 @@ export type ValidationScope = {
     fields?: Record<string, unknown>;
     settings?: Record<string, unknown>;
 };
+/** A link field takes only what the site renders (richtext-href.ts's rule): the widget says so as the editor types,
+ *  publish refuses it (register 2026-09-26, the content-surface sweep). */
+export declare const LINK_MESSAGE = "A link starts with https://, http://, mailto:, tel:, / for a page on this site, # or ?.";
+export declare const linkProblem: (value: unknown) => string | null;
 /** The element schemas an element node is validated against (spec 2026-09-08 block nodes §2). */
 export type ElementDescs = Record<string, {
     fields: Record<string, Desc>;

package/dist/admin/validate.js

@@ -14,9 +14,14 @@ import { rowsProblems } from "../custom/rows.js";
 import { isCalendarDay, isInstant } from "./forms/date-picker.js";
 import { fits, misfitMessage } from "./drift.js";
 import { isSegment } from "../paths.js";
+import { safeHref } from "../richtext-href.js";
 import { isCrop } from "../media.js";
 /** A slug outside the path grammar, at publish (spec 2026-09-28 ASCII slugs §3). */
 export const SLUG_GRAMMAR_MESSAGE = "Use lowercase letters, digits and single hyphens, like my-post.";
+/** A link field takes only what the site renders (richtext-href.ts's rule): the widget says so as the editor types,
+ *  publish refuses it (register 2026-09-26, the content-surface sweep). */
+export const LINK_MESSAGE = "A link starts with https://, http://, mailto:, tel:, / for a page on this site, # or ?.";
+export const linkProblem = (value) => typeof value === "string" && value.trim() !== "" && safeHref(value) === null ? LINK_MESSAGE : null;
 const subfields = (d) => d.fields && typeof d.fields === "object" ? d.fields : {};
 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);
@@ -47,6 +52,10 @@ function validateValue(path, value, d, errors, elements, scope) {
         errors.push({ field: path, message: SLUG_GRAMMAR_MESSAGE });
         return;
     }
+    if (d.type === "link" && linkProblem(value)) {
+        errors.push({ field: path, message: LINK_MESSAGE });
+        return;
+    }
     if (d.type === "richtext") {
         if (!hasContent(value)) {
             if (!mayBeAbsent(d))

package/dist/astro/components/RichText.astro

@@ -19,5 +19,6 @@ const chunks = richtextChunks(doc);
   // An own name only: `constructor` or `toString` must not find Object's members.
   const View = Object.prototype.hasOwnProperty.call(views.elements, chunk.name) ? views.elements[chunk.name] : undefined;
   if (!View) { console.warn(`smoodly: no src/elements/${chunk.name}.astro for element "${chunk.name}" — skipping.`); return null; }
-  return <View {...chunk.fields} settings={{ ...info.element(chunk.name).defaults, ...chunk.settings }} />;
+  // `styles={{}}` as the React pairing hands it (pairing.tsx: `styles ?? {}`), so a view that reads styles never throws here.
+  return <View {...chunk.fields} settings={{ ...info.element(chunk.name).defaults, ...chunk.settings }} styles={{}} />;
 })}

package/dist/astro/preview.d.ts

@@ -1,8 +1,11 @@
 export declare const DRAFT_COOKIE = "smoodly-draft";
 export declare const PREVIEW_BASE = "/_smoodly/preview";
-export declare function draftCookieValue(secret: string): Promise<string>;
-/** `verify` compares in constant time. */
-export declare function isDraftCookie(value: string | undefined, secret: string): Promise<boolean>;
+/** Seconds: the browser's Max-Age and the signed expiry agree. */
+export declare const DRAFT_COOKIE_MAX_AGE: number;
+/** `2.<expiry ms>.<hex signature>`; `now` is for tests. */
+export declare function draftCookieValue(secret: string, now?: number): Promise<string>;
+/** `verify` compares in constant time; an expired value is refused before the key is touched. */
+export declare function isDraftCookie(value: string | undefined, secret: string, now?: number): Promise<boolean>;
 /** The page path a preview address names ("/" for the base itself), or null when `pathname` is not one. */
 export declare function previewPath(pathname: string): string | null;
 /** The page path a preview address may rewrite to: never the admin, never a preview address again (a

package/dist/astro/preview.js

@@ -1,25 +1,38 @@
 // The preview address and its key (DESIGN.md Vision, preview per framework; spec 2026-10-02 astro cloud
 // fit §7): Astro serves every draft under PREVIEW_BASE, to a browser that holds the draft cookie. The
-// cookie's value is an HMAC of a fixed message under the site's secret key: the draft operation, which
-// only a signed-in editor can call, is the only thing that can make one. Web Crypto only, so the code
-// runs on any host.
+// cookie's value is an HMAC under the site's secret key over a message carrying its expiry: the draft
+// operation, which only a signed-in editor can call, is the only thing that can make one, and a value
+// ends twelve hours after it was made, with the browser's Max-Age (register 2026-10-05: before, one
+// fixed value served every editor for as long as the key stood). Web Crypto only, so the code runs on
+// any host.
 export const DRAFT_COOKIE = "smoodly-draft";
 export const PREVIEW_BASE = "/_smoodly/preview";
+/** Seconds: the browser's Max-Age and the signed expiry agree. */
+export const DRAFT_COOKIE_MAX_AGE = 12 * 3600;
 const encoder = new TextEncoder();
-const MESSAGE = encoder.encode("smoodly-draft:v1");
+const VERSION = "2";
+const message = (expiry) => encoder.encode(`smoodly-draft:v${VERSION}:${expiry}`);
 const keyOf = (secret) => crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
-export async function draftCookieValue(secret) {
+/** `2.<expiry ms>.<hex signature>`; `now` is for tests. */
+export async function draftCookieValue(secret, now = Date.now()) {
     if (!secret)
         throw new Error("smoodly: the draft cookie needs SMOODLY_SECRET_KEY.");
-    const signature = await crypto.subtle.sign("HMAC", await keyOf(secret), MESSAGE);
-    return [...new Uint8Array(signature)].map((b) => b.toString(16).padStart(2, "0")).join("");
+    const expiry = now + DRAFT_COOKIE_MAX_AGE * 1000;
+    const signature = await crypto.subtle.sign("HMAC", await keyOf(secret), message(expiry));
+    return `${VERSION}.${expiry}.${[...new Uint8Array(signature)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
 }
-/** `verify` compares in constant time. */
-export async function isDraftCookie(value, secret) {
-    if (!secret || !value || !/^[0-9a-f]{64}$/.test(value))
+/** `verify` compares in constant time; an expired value is refused before the key is touched. */
+export async function isDraftCookie(value, secret, now = Date.now()) {
+    if (!secret || !value)
         return false;
-    const signature = Uint8Array.from(value.match(/../g), (pair) => parseInt(pair, 16));
-    return crypto.subtle.verify("HMAC", await keyOf(secret), signature, MESSAGE);
+    const m = /^2\.(\d{1,16})\.([0-9a-f]{64})$/.exec(value);
+    if (!m)
+        return false;
+    const expiry = Number(m[1]);
+    if (!(expiry > now))
+        return false;
+    const signature = Uint8Array.from(m[2].match(/../g), (pair) => parseInt(pair, 16));
+    return crypto.subtle.verify("HMAC", await keyOf(secret), signature, message(expiry));
 }
 /** The page path a preview address names ("/" for the base itself), or null when `pathname` is not one. */
 export function previewPath(pathname) {

package/dist/astro/richtext.js

@@ -1,4 +1,4 @@
-import { escapeHtml, isResolvedImage, safeHref } from "../richtext-href.js";
+import { escapeHtml, isResolvedImage, safeHref, textOf } from "../richtext-href.js";
 import { ELEMENT_NODE, IMAGE_NODE } from "../richtext-walk.js";
 const asRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
 const WRAP = { paragraph: "p", bulletList: "ul", orderedList: "ol", listItem: "li", blockquote: "blockquote" };
@@ -26,7 +26,7 @@ export function richtextChunks(doc) {
         }
         switch (node.type) {
             case "text":
-                html += withMarks(escapeHtml(node.text ?? ""), node.marks ?? []);
+                html += withMarks(escapeHtml(textOf(node.text)), node.marks ?? []);
                 return;
             case "heading": {
                 const level = Math.min(6, Math.max(1, Math.round(Number(node.attrs?.level ?? 1) || 1)));

package/dist/astro/routes/admin.js

@@ -6,7 +6,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createAdminHandler } from "../../admin/handler.js";
 import { expire } from "../cache.js";
-import { DRAFT_COOKIE, PREVIEW_BASE, draftCookieValue } from "../preview.js";
+import { DRAFT_COOKIE, DRAFT_COOKIE_MAX_AGE, PREVIEW_BASE, draftCookieValue } from "../preview.js";
 import { output } from "smoodly:build";
 import { adminDeps, secret } from "../server.js";
 export const prerender = false;
@@ -29,7 +29,7 @@ const handle = createAdminHandler(() => ({
             enable: async () => {
                 const { context } = effects();
                 context.cookies.set(DRAFT_COOKIE, await draftCookieValue(secret()), {
-                    path: PREVIEW_BASE, httpOnly: true, sameSite: "lax", secure: secure(context),
+                    path: PREVIEW_BASE, httpOnly: true, sameSite: "lax", secure: secure(context), maxAge: DRAFT_COOKIE_MAX_AGE,
                 });
             },
             disable: () => effects().context.cookies.delete(DRAFT_COOKIE, { path: PREVIEW_BASE }),

package/dist/config.js

@@ -19,12 +19,12 @@ function normalizeRegistry(config) {
         }
     }
     return {
-        sections: (config.registry.sections ?? []).map((s) => schemaOnly(s)),
-        elements: (config.registry.elements ?? []).map((e) => schemaOnly(e)),
+        sections: (config.registry.sections ?? []).map((s) => schemaOnly(s, "registry.sections")),
+        elements: (config.registry.elements ?? []).map((e) => schemaOnly(e, "registry.elements")),
         collections,
         globals: config.registry.globals ?? [],
         // Page types only: an entry page is a view, registered with defineViews, and schemaOnly refuses it here.
-        pages: (config.registry.pages ?? []).map((p) => schemaOnly(p)),
+        pages: (config.registry.pages ?? []).map((p) => schemaOnly(p, "registry.pages")),
     };
 }
 /** Names are unique per kind (plan 2026-10-02 registration split): a section and a collection may share one. */
@@ -152,6 +152,9 @@ function assertLocales(config) {
     }
     if (!supported.includes(def))
         throw new Error(`smoodly: the default locale "${def}" is not in the supported list.`);
+    const twice = supported.find((code, i) => supported.indexOf(code) !== i);
+    if (twice !== undefined)
+        throw new Error(`smoodly: the locale "${twice}" is listed twice in supported — list each locale once.`);
 }
 function assertTimeZone(config) {
     if (config.timeZone === undefined)

package/dist/css.js

@@ -10,6 +10,10 @@ export const CSS_MAX = 4000;
 const REFUSED = [
     [/@import/i, "@import is not allowed."],
     [/url\s*\(/i, "url() is not allowed."],
+    // The other image functions take a bare string, so they can fetch as url() can.
+    [/image-set\s*\(/i, "image-set() is not allowed."],
+    [/image\s*\(/i, "image() is not allowed."],
+    [/src\s*\(/i, "src() is not allowed."],
     [/expression\s*\(/i, "expression() is not allowed."],
     [/behavior\s*:/i, "behavior: is not allowed."],
     [/<\//, '"</" is not allowed.'],

package/dist/custom/index.js

@@ -8,6 +8,9 @@ export function withCustomSchema(sections, toolset) {
     return [...sections, customSchema(toolset)];
 }
 export function resolveCustom(input) {
+    // The pre-split shape (custom.RichText) would be dropped without a word; an untyped config can still carry it.
+    if (input && "RichText" in input)
+        throw new Error("smoodly: custom.RichText is a view — give the bound RichText to defineViews({ RichText }), not to the config.");
     const breakpoint = input?.breakpoint ?? DEFAULT_BREAKPOINT;
     if (!isCssLength(breakpoint))
         throw new Error(`smoodly: custom.breakpoint "${breakpoint}" must be a length like "48rem" or "768px".`);

package/dist/entry-store.d.ts

@@ -14,6 +14,9 @@ export type EntryLocale = {
     /** The draft version's saved time as the store's own text (spec 2026-09-26 concurrency §1). Null with no pointer. */
     draftSavedAt: string | null;
     publishedVersionId: string | null;
+    /** When the published snapshot last moved (null never published): what a published read shows as `updatedAt`, so a
+     *  draft save after it moves nothing on the site (register 2026-09-30). */
+    publishedAt: number | null;
     updatedAt: number;
     /** The editor's email behind the last write that touched this row; null for the seed and scripts (spec 2026-09-13 history §2). */
     updatedBy: string | null;

package/dist/image/markup.js

@@ -36,7 +36,21 @@ function srcsetOf(cut, width, d) {
 function frameOverCut(image, rect, box) {
     const spot = image.hotspot ?? CENTER_HOTSPOT;
     const hotspot = { x: clamp01((spot.x * image.width - rect.left) / rect.width), y: clamp01((spot.y * image.height - rect.top) / rect.height) };
-    return frameStyle(frameFor({ width: rect.width, height: rect.height, hotspot }, box));
+    return frameFor({ width: rect.width, height: rect.height, hotspot }, box);
+}
+/** `sizes` describes the box; a frame wider than the box shows the cut at `k` times that width, so each length is
+ *  scaled, or the browser picks a candidate narrower than what it draws (register 2026-09-08). Each entry is an
+ *  optional media condition in parentheses and a length, which calc() may wrap. */
+function scaleSizes(sizes, k) {
+    if (k <= 1.005)
+        return sizes;
+    const factor = Math.round(k * 1000) / 1000;
+    return sizes.split(",").map((entry) => {
+        const m = /^(\s*)(\([^)]*\)\s*)?(.+?)(\s*)$/.exec(entry);
+        if (!m)
+            return entry;
+        return `${m[1]}${m[2] ?? ""}calc(${m[3]} * ${factor})${m[4]}`;
+    }).join(",");
 }
 export function imageMarkup(image, options) {
     const loading = options.priority ? "eager" : options.loading ?? "lazy";
@@ -71,12 +85,14 @@ export function imageMarkup(image, options) {
     if (rect && image.cut) {
         const own = rect.width / rect.height;
         const box = options.aspect ? parseAspect(options.aspect) : own;
+        const frame = Math.abs(box / own - 1) < 0.005 ? null : frameOverCut(image, rect, box);
+        const shown = frame && options.sizes ? { sizes: scaleSizes(options.sizes, frame.width / 100) } : sizes;
         return {
             box: boxStyle(box),
             sources,
             img: {
-                ...srcsetOf(image.cut, rect.width, delivery), ...sizes, ...tag, width: rect.width, height: rect.height,
-                style: Math.abs(box / own - 1) < 0.005 ? FULL : frameOverCut(image, rect, box),
+                ...srcsetOf(image.cut, rect.width, delivery), ...shown, ...tag, width: rect.width, height: rect.height,
+                style: frame ? frameStyle(frame) : FULL,
             },
         };
     }

package/dist/read-shapes.d.ts

@@ -56,6 +56,7 @@ export declare function toEntryItem(record: EntryRecord, fields: Record<string,
     locale: string;
     locales: Record<string, LocaleAlternate | null>;
     seo?: Seo;
+    draft?: boolean;
 }): EntryItem;
 /** One page as a read returns it: no record, no tree. */
 export declare function toPageItem(hit: SitePage): PageItem;

package/dist/read-shapes.js

@@ -3,9 +3,12 @@ import { SEO_KEY } from "./seo.js";
 export function toEntryItem(record, fields, o) {
     // The reserved `$seo` values are Smoodly's: they leave as `seo`, never as a field.
     const { [SEO_KEY]: _seo, ...rest } = fields;
+    const row = record.locales[o.locale];
+    // A published read shows when the published snapshot last moved; the draft read follows the live row.
+    const updatedAt = (o.draft ? null : row?.publishedAt ?? null) ?? row?.updatedAt ?? record.updatedAt;
     return {
         id: record.id, path: o.path, locale: o.locale, locales: o.locales,
-        updatedAt: record.locales[o.locale]?.updatedAt ?? record.updatedAt, fields: rest,
+        updatedAt, fields: rest,
         ...(o.seo ? { seo: o.seo } : {}),
     };
 }

package/dist/registration.d.ts

@@ -2,7 +2,8 @@ export type SchemaOr<S> = S | {
     schema: S;
 };
 export declare function schemaOf<S extends object>(x: SchemaOr<S>): S;
-/** The schema a public builder was given, refusing a paired component (plan 2026-10-02 registration split). */
+/** The schema a public builder was given, refusing a paired component (plan 2026-10-02 registration split) and a
+ *  plain function, which would pass as a schema named after itself (register 2026-10-03); `where` names the list. */
 export declare function schemaOnly<S extends {
     name: string;
-}>(x: S): S;
+}>(x: S, where?: string): S;

package/dist/registration.js

@@ -2,9 +2,14 @@ export function schemaOf(x) {
     const carried = x.schema;
     return carried !== null && typeof carried === "object" ? carried : x;
 }
-/** The schema a public builder was given, refusing a paired component (plan 2026-10-02 registration split). */
-export function schemaOnly(x) {
+/** The schema a public builder was given, refusing a paired component (plan 2026-10-02 registration split) and a
+ *  plain function, which would pass as a schema named after itself (register 2026-10-03); `where` names the list. */
+export function schemaOnly(x, where) {
     const carried = x.schema;
+    if (typeof x === "function" && (carried === null || typeof carried !== "object")) {
+        const name = String(x.name || "anonymous");
+        throw new Error(`smoodly: ${where ?? "a registration"} holds a function "${name}", not a schema — register the schema (${name}Schema) and give defineViews the component.`);
+    }
     if (carried !== null && typeof carried === "object") {
         if (carried.kind === "entryPage") {
             const c = String(carried.collection);

package/dist/richtext/index.js

@@ -2,6 +2,15 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { RichText } from "../richtext-render.js";
 import { SmoodlyImage } from "../image/SmoodlyImage.js";
 export function createRichText({ elements = [], sizes } = {}) {
+    // A schema where a paired element belongs would fail at the first render on `undefined.name`; name it here (register 2026-10-03).
+    for (const e of elements) {
+        if (e && typeof e.schema === "object")
+            continue;
+        const name = e?.name;
+        throw new Error(typeof name === "string"
+            ? `smoodly: createRichText({ elements }) got the schema "${name}" where a component belongs — pair it first: smoodly.element(${name}Schema, View).`
+            : `smoodly: createRichText({ elements }) got ${e === null ? "null" : typeof e} where a paired element belongs.`);
+    }
     const image = ({ image, caption }) => (_jsxs("figure", { children: [_jsx(SmoodlyImage, { image: image, sizes: sizes }), caption !== "" && _jsx("figcaption", { children: caption })] }));
     function Bound({ doc }) {
         return _jsx(RichText, { doc: doc, elements: elements, image: image });

package/dist/richtext-href.d.ts

@@ -1,4 +1,6 @@
 import type { ResolvedImage } from "./media.ts";
 export declare function safeHref(raw: unknown): string | null;
+/** A text node's text as both renderers show it: a string or a number; anything else is nothing, never a throw. */
+export declare const textOf: (v: unknown) => string;
 export declare function escapeHtml(text: string): string;
 export declare const isResolvedImage: (v: unknown) => v is ResolvedImage;

package/dist/richtext-href.js

@@ -9,6 +9,8 @@ export function safeHref(raw) {
     const href = raw.replace(/[\t\n\r]/g, "").trim();
     return href !== "" && SAFE_HREF.test(href) ? href : null;
 }
+/** A text node's text as both renderers show it: a string or a number; anything else is nothing, never a throw. */
+export const textOf = (v) => (typeof v === "string" ? v : typeof v === "number" ? String(v) : "");
 const ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#x27;" };
 export function escapeHtml(text) {
     return text.replace(/[&<>"']/g, (c) => ESCAPES[c]);

package/dist/richtext-render.js

@@ -9,7 +9,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // (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 { isResolvedImage, safeHref } from "./richtext-href.js";
+import { isResolvedImage, safeHref, textOf } from "./richtext-href.js";
 import { ELEMENT_NODE, IMAGE_NODE } from "./richtext-walk.js";
 /** 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. */
@@ -31,7 +31,7 @@ function renderNode(node, r) {
         return null;
     const children = Array.isArray(node.content) ? renderNodes(node.content, r) : null;
     switch (node.type) {
-        case "text": return withMarks(node.text ?? "", node.marks ?? []);
+        case "text": return withMarks(textOf(node.text), node.marks ?? []);
         case "paragraph": return _jsx("p", { children: children });
         case "heading": {
             const level = Math.min(6, Math.max(1, Math.round(Number(node.attrs?.level ?? 1) || 1)));
@@ -53,8 +53,9 @@ function renderNode(node, r) {
             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 settings = a.settings && typeof a.settings === "object" ? a.settings : {};
+            // A record only, as the Astro renderer takes it: an array spread as props is nonsense.
+            const fields = a.fields && typeof a.fields === "object" && !Array.isArray(a.fields) ? a.fields : {};
+            const settings = a.settings && typeof a.settings === "object" && !Array.isArray(a.settings) ? a.settings : {};
             return _jsx(Component, { ...fields, settings: settings });
         }
         default: return children;

package/dist/store.d.ts

@@ -195,3 +195,6 @@ export declare function pageRefEdges(trees: PageTree[], sections: SectionLike[],
  * THERE — every referenced entry must exist, have a row in that locale,
  * and be published in it. Throws naming the offenders. */
 export declare function assertPublishable(label: string, tree: PageTree, sections: SectionLike[], entries: EntryStore, locale: string): Promise<void>;
+/** The same rule for any set of reference edges: an entry's or a global item's fields publish only when every
+ *  entry they reference is published in that locale (register 2026-09-14: pages were gated, entries were not). */
+export declare function assertRefsPublished(label: string, edges: RefEdge[], entries: EntryStore, locale: string): Promise<void>;

package/dist/store.js

@@ -83,8 +83,13 @@ export function pageRefEdges(trees, sections, elements) {
  * THERE — every referenced entry must exist, have a row in that locale,
  * and be published in it. Throws naming the offenders. */
 export async function assertPublishable(label, tree, sections, entries, locale) {
+    await assertRefsPublished(label, collectTreeRefs(tree, sections), entries, locale);
+}
+/** The same rule for any set of reference edges: an entry's or a global item's fields publish only when every
+ *  entry they reference is published in that locale (register 2026-09-14: pages were gated, entries were not). */
+export async function assertRefsPublished(label, edges, entries, locale) {
     const targets = new Map();
-    for (const edge of collectTreeRefs(tree, sections)) {
+    for (const edge of edges) {
         if (edge.targetCollection === ASSET_COLLECTION)
             continue; // assets are immediate, never draft-gated
         if (!targets.has(edge.targetId))

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.55";
+export declare const SMOODLY_VERSION = "0.0.56";

package/dist/version.js

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

package/dist/views.js

@@ -1,3 +1,20 @@
+/** Every entry of a defineViews list is a paired component; a bare schema or a plain function is named here, where
+ *  `undefined.name` would have been the word (register 2026-10-03). */
+function assertPaired(key, builder, views) {
+    for (const v of views) {
+        const schema = v?.schema;
+        if (schema && typeof schema === "object")
+            continue;
+        const name = v?.name;
+        if (typeof v === "function") {
+            throw new Error(`smoodly: defineViews({ ${key} }) got a plain function "${String(name)}" where a paired component belongs — pair it first: smoodly.${builder}(schema, View).`);
+        }
+        if (v && typeof v === "object" && typeof name === "string") {
+            throw new Error(`smoodly: defineViews({ ${key} }) got the schema "${name}" where a component belongs — pair it first: smoodly.${builder}(${name}Schema, View).`);
+        }
+        throw new Error(`smoodly: defineViews({ ${key} }) got ${v === null ? "null" : typeof v} where a paired component belongs.`);
+    }
+}
 function match(what, key, schemas, views) {
     const registered = new Map(schemas.map((s) => [s.name, s]));
     const viewed = new Set();
@@ -8,6 +25,8 @@ function match(what, key, schemas, views) {
         if (schema !== v.schema) {
             throw new Error(`smoodly: the view for ${what} "${v.schema.name}" is paired with a different schema object than the one in the config — pair it with the registered schema.`);
         }
+        if (viewed.has(v.schema.name))
+            throw new Error(`smoodly: two views are paired with ${what} "${v.schema.name}" — keep one in defineViews({ ${key} }).`);
         viewed.add(v.schema.name);
     }
     for (const s of schemas) {
@@ -17,6 +36,14 @@ function match(what, key, schemas, views) {
 }
 export function defineViews(config, views) {
     const elements = views.elements ?? [];
+    assertPaired("sections", "section", views.sections);
+    assertPaired("elements", "element", elements);
+    assertPaired("pages", "page", views.pages);
+    for (const p of views.pages) {
+        if (p.schema.kind !== "page" && p.schema.kind !== "entryPage") {
+            throw new Error(`smoodly: defineViews({ pages }) got the ${p.schema.kind} "${p.schema.name}" — pages holds page types and entry pages; ${p.schema.kind}s go to defineViews({ ${p.schema.kind}s }).`);
+        }
+    }
     match("section", "sections", config.registry.sections, views.sections);
     match("element", "elements", config.registry.elements, elements);
     match("page type", "pages", config.registry.pages, views.pages.filter((p) => p.schema.kind === "page"));

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "smoodly",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "Open-source, code-first CMS for Astro and Next.js: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
+  "engines": {
+    "node": ">=22.12"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/smoodly-io/smoodly.git",
@@ -51,6 +54,7 @@
       "types": "./dist/richtext/index.d.ts",
       "default": "./dist/richtext/index.js"
     },
+    "./package.json": "./package.json",
     "./admin": {
       "types": "./dist/admin/index.d.ts",
       "default": "./dist/admin/index.js"