smoodly 0.0.55 → 0.0.57

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

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

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.57",
   "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"