smoodly 0.0.45 → 0.0.47

package/dist/config.js

@@ -5,51 +5,49 @@ import { DEFAULT_ADMIN_PATH, assertAdminPath, isAdminSlug } from "./admin-path.j
 import { resolveStyleValues, styleDescriptors } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
 import { isValidZone } from "./time-zone.js";
+import { schemaOnly } from "./registration.js";
 /** `global`: the placement node type and an admin route; `asset`: the refs
  *  target of every media edge; `media`: the admin's Media screen route. */
 export const RESERVED_NAMES = ["global", "asset", "media"];
 const isReserved = (name) => RESERVED_NAMES.includes(name);
-function assertUniqueNames(config) {
-    const seen = new Set();
-    const sectionNameList = (config.registry.sections ?? []).map((s) => s.schema.name);
-    const sectionNames = new Set(sectionNameList);
-    const all = [
-        ...sectionNameList,
-        ...(config.registry.elements ?? []).map((e) => e.schema.name),
-        ...(config.registry.collections ?? []).map((c) => c.name),
-        ...(config.registry.pages ?? []).filter((p) => p.schema.kind !== "entryPage").map((p) => p.schema.name),
-    ];
-    for (const name of all) {
-        if (isReserved(name))
-            throw new Error(`smoodly: "${name}" is a reserved name.`);
-        if (seen.has(name))
-            throw new Error(`smoodly: duplicate registered name "${name}".`);
-        seen.add(name);
-    }
-    // Global items get their own pass, after every other kind is settled: a
-    // global item's name must be unique among global items, and must not
-    // collide with any collection/element/page/section name above — EXCEPT a
-    // visual item may reuse the name of the registered section it renders
-    // (spec 2026-09-07 §2's example pairs a "footer" section with a "footer"
-    // item). That exemption is narrow: it only excuses a match against the
-    // item's own, actually-registered section — never against a collection,
-    // element, or page that happens to share the string, and never against a
-    // second global item of the same name.
-    const globalSeen = new Set();
-    for (const item of config.registry.globals ?? []) {
-        const ownSection = item.name === item.section && sectionNames.has(item.name);
-        if (isReserved(item.name))
-            throw new Error(`smoodly: "${item.name}" is a reserved name.`);
-        if (globalSeen.has(item.name) || (seen.has(item.name) && !ownSection)) {
-            throw new Error(`smoodly: duplicate registered name "${item.name}".`);
+function normalizeRegistry(config) {
+    const collections = config.registry.collections ?? [];
+    for (const c of collections) {
+        if (c.kind === "global") {
+            throw new Error(`smoodly: "${c.name}" is a global item — list it under registry.globals, not registry.collections.`);
         }
-        globalSeen.add(item.name);
     }
+    return {
+        sections: (config.registry.sections ?? []).map((s) => schemaOnly(s)),
+        elements: (config.registry.elements ?? []).map((e) => schemaOnly(e)),
+        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)),
+    };
+}
+/** Names are unique per kind (plan 2026-10-02 registration split): a section and a collection may share one. */
+function assertUniqueNames(registry) {
+    const check = (names, what) => {
+        const seen = new Set();
+        for (const name of names) {
+            if (isReserved(name))
+                throw new Error(`smoodly: "${name}" is a reserved name.`);
+            if (seen.has(name))
+                throw new Error(`smoodly: duplicate ${what} name "${name}".`);
+            seen.add(name);
+        }
+    };
+    // One component map renders sections and elements, so they share a namespace.
+    check([...registry.sections, ...registry.elements].map((s) => s.name), "section or element");
+    // A global item is stored as an entry of a collection named after it, so the two share one.
+    check([...registry.collections, ...registry.globals].map((c) => c.name), "collection or global item");
+    check(registry.pages.map((p) => p.name), "page type");
 }
 /** A visual item renders through a registered section. */
-function assertGlobalSections(config) {
-    const sections = new Set((config.registry.sections ?? []).map((s) => s.schema.name));
-    for (const item of config.registry.globals ?? []) {
+function assertGlobalSections(registry) {
+    const sections = new Set(registry.sections.map((s) => s.name));
+    for (const item of registry.globals) {
         if (item.section !== undefined && !sections.has(item.section)) {
             throw new Error(`smoodly: global item "${item.name}" renders section "${item.section}", which is not registered.`);
         }
@@ -62,39 +60,35 @@ function assertGlobalSections(config) {
  *  path, which is the collection's index page — and nothing may sit
  *  inside a collection's address. An address starting at the admin's
  *  segment is refused outright (spec 2026-09-17 slug guard §5). */
-function assertRootSegments(config, adminPath) {
-    const { default: def } = config.locales;
+function assertRootSegments(registry, locales, adminPath) {
+    const { default: def } = locales;
     // Fixed slugs and collection paths both fill an omitted locale from the
     // default one — where the materializer puts the record and the entry
     // derivation puts the entries — so the checks see every clash at boot.
-    const pageSegments = (v) => fixedPageSegments(v, config.locales);
-    const pages = (config.registry.pages ?? []).filter((p) => p.schema.kind === "page" && p.schema.slug !== undefined);
+    const pageSegments = (v) => fixedPageSegments(v, locales);
+    const pages = registry.pages.filter((p) => p.slug !== undefined);
     const owners = new Map(); // "<locale> <segment>" → page name
     for (const p of pages) {
-        const slug = p.schema.slug;
+        const slug = p.slug;
         if (typeof slug !== "string" && slug[def] === undefined) {
-            throw new Error(`smoodly: page "${p.schema.name}" declares a per-locale slug without the default locale "${def}".`);
+            throw new Error(`smoodly: page "${p.name}" declares a per-locale slug without the default locale "${def}".`);
         }
         for (const [locale, segment] of Object.entries(pageSegments(slug))) {
-            assertAddress(segment, `page "${p.schema.name}" fixed slug`);
+            assertAddress(segment, `page "${p.name}" fixed slug`);
             if (isAdminSlug(segment.split("/")[0], adminPath)) {
-                throw new Error(`smoodly: page "${p.schema.name}" has the fixed slug "${segment}", where the admin lives — change its slug or admin.path.`);
+                throw new Error(`smoodly: page "${p.name}" has the fixed slug "${segment}", where the admin lives — change its slug or admin.path.`);
             }
             const owner = owners.get(`${locale} ${segment}`);
             if (owner) {
-                throw new Error(`smoodly: page registrations "${owner}" and "${p.schema.name}" both claim the fixed slug "${segment}" (${locale}).`);
+                throw new Error(`smoodly: page registrations "${owner}" and "${p.name}" both claim the fixed slug "${segment}" (${locale}).`);
             }
-            owners.set(`${locale} ${segment}`, p.schema.name);
+            owners.set(`${locale} ${segment}`, p.name);
         }
     }
-    const entryPages = new Set((config.registry.pages ?? []).filter((p) => p.schema.kind === "entryPage").map((p) => p.schema.collection));
     const collectionOwners = new Map();
-    for (const c of config.registry.collections ?? []) {
+    for (const c of registry.collections) {
         if (c.path === undefined)
             continue;
-        if (!entryPages.has(c.name)) {
-            throw new Error(`smoodly: collection "${c.name}" declares a path but no entry page — register smoodly.entryPage(${c.name}, View).`);
-        }
         if (typeof c.path !== "string" && c.path[def] === undefined) {
             throw new Error(`smoodly: collection "${c.name}" declares a per-locale path without the default locale "${def}".`);
         }
@@ -115,8 +109,8 @@ function assertRootSegments(config, adminPath) {
             const pageName = owners.get(`${locale} ${segment}`);
             if (!pageName)
                 continue;
-            const page = pages.find((p) => p.schema.name === pageName);
-            const everywhere = Object.entries(segments).every(([l, s]) => pageSegments(page.schema.slug)[l] === s);
+            const page = pages.find((p) => p.name === pageName);
+            const everywhere = Object.entries(segments).every(([l, s]) => pageSegments(page.slug)[l] === s);
             if (!everywhere) {
                 throw new Error(`smoodly: collection "${c.name}" and page registration "${pageName}" both claim the address "${segment}" (${locale}).`);
             }
@@ -125,15 +119,15 @@ function assertRootSegments(config, adminPath) {
     // A collection's entries live below its address: nothing else may sit there (spec 2026-09-29 nested paths §2).
     const claims = [];
     for (const p of pages)
-        for (const [locale, address] of Object.entries(pageSegments(p.schema.slug)))
-            claims.push({ what: `page "${p.schema.name}"`, locale, address });
-    for (const c of config.registry.collections ?? []) {
+        for (const [locale, address] of Object.entries(pageSegments(p.slug)))
+            claims.push({ what: `page "${p.name}"`, locale, address });
+    for (const c of registry.collections) {
         if (c.path === undefined)
             continue;
         for (const [locale, address] of Object.entries(pageSegments(c.path)))
             claims.push({ what: `collection "${c.name}"`, locale, address });
     }
-    for (const c of config.registry.collections ?? []) {
+    for (const c of registry.collections) {
         if (c.path === undefined)
             continue;
         for (const [locale, base] of Object.entries(pageSegments(c.path))) {
@@ -184,18 +178,18 @@ function toolsetElementNames(descriptors, out) {
     }
 }
 /** A field can never offer an element the admin cannot serialize (spec 2026-09-08 block nodes §1). */
-function assertToolsetElements(config) {
-    const registered = new Set((config.registry.elements ?? []).map((e) => e.schema.name));
+function assertToolsetElements(registry, custom) {
+    const registered = new Set(registry.elements.map((e) => e.name));
     const wanted = new Set();
-    for (const s of config.registry.sections ?? [])
-        toolsetElementNames(s.schema.fields, wanted);
-    for (const e of config.registry.elements ?? [])
-        toolsetElementNames(e.schema.fields, wanted);
-    for (const c of config.registry.collections ?? [])
+    for (const s of registry.sections)
+        toolsetElementNames(s.fields, wanted);
+    for (const e of registry.elements)
+        toolsetElementNames(e.fields, wanted);
+    for (const c of registry.collections)
         toolsetElementNames(c.fields, wanted);
-    for (const s of config.registry.globals ?? [])
+    for (const s of registry.globals)
         toolsetElementNames(s.fields, wanted);
-    for (const n of config.custom?.toolset?.elements ?? [])
+    for (const n of custom?.toolset?.elements ?? [])
         wanted.add(n);
     for (const name of wanted) {
         if (!registered.has(name))
@@ -205,12 +199,13 @@ function assertToolsetElements(config) {
 export function defineConfig(config) {
     assertLocales(config);
     assertTimeZone(config);
-    assertUniqueNames(config);
-    assertGlobalSections(config);
-    assertToolsetElements(config);
+    const registry = normalizeRegistry(config);
+    assertUniqueNames(registry);
+    assertGlobalSections(registry);
+    assertToolsetElements(registry, config.custom);
     const adminPath = config.admin?.path ?? DEFAULT_ADMIN_PATH;
     assertAdminPath(adminPath);
-    assertRootSegments(config, adminPath);
+    assertRootSegments(registry, config.locales, adminPath);
     const depth = config.pages?.tree?.depth ?? 1;
     if (!Number.isInteger(depth) || depth < 1)
         throw new Error("smoodly: pages.tree.depth must be a positive integer.");
@@ -218,7 +213,7 @@ export function defineConfig(config) {
     // collection's mount: that node is a folder or an index page, never "/".
     const homePageSlug = config.homePageSlug ?? "home";
     assertSegment(homePageSlug, "homePageSlug");
-    for (const c of config.registry.collections ?? []) {
+    for (const c of registry.collections) {
         if (c.path === undefined)
             continue;
         const segment = typeof c.path === "string" ? c.path : c.path[config.locales.default];
@@ -229,7 +224,7 @@ export function defineConfig(config) {
     // A code-owned record keeps its address's last part as its slug, and the
     // root record slugged homePageSlug IS the home page: a nested address
     // ending in it would serve "/" (spec 2026-09-29 nested paths §3).
-    for (const a of codeAddresses({ locales: config.locales, pages: config.registry.pages ?? [], collections: config.registry.collections ?? [] })) {
+    for (const a of codeAddresses({ locales: config.locales, pages: registry.pages, collections: registry.collections })) {
         for (const [locale, address] of Object.entries(a.segments)) {
             if (address.includes("/") && lastPart(address) === homePageSlug) {
                 throw new Error(`smoodly: the address "${address}" (${locale}) ends in homePageSlug "${homePageSlug}" — its record would be the home page; end it in another segment.`);
@@ -238,7 +233,7 @@ export function defineConfig(config) {
     }
     const styles = resolveStyleValues(config.styles);
     const custom = resolveCustom(config.custom);
-    const byName = new Map((config.registry.sections ?? []).map((s) => [s.schema.name, s.schema]));
+    const byName = new Map(registry.sections.map((s) => [s.name, s]));
     const media = {
         maxSize: config.media?.maxSize ?? DEFAULT_MEDIA.maxSize,
         accept: config.media?.accept ? [...config.media.accept] : [...DEFAULT_MEDIA.accept],
@@ -246,9 +241,10 @@ export function defineConfig(config) {
     if (!Number.isInteger(media.maxSize) || media.maxSize <= 0) {
         throw new Error("smoodly: media.maxSize must be a positive integer of bytes.");
     }
-    const addresses = addressMap(codeAddresses({ locales: config.locales, pages: config.registry.pages ?? [], collections: config.registry.collections ?? [] }));
+    const addresses = addressMap(codeAddresses({ locales: config.locales, pages: registry.pages, collections: registry.collections }));
     return {
         ...config,
+        registry,
         homePageSlug,
         pageDepth: depth,
         media,

package/dist/content/content-api.d.ts

@@ -3,7 +3,7 @@ import type { EntryCreateInput, OpError, PageCreateInput } from "../admin/ops.ts
 import type { FieldError } from "../admin/validate.ts";
 import type { EntryRecord } from "../entry-store.ts";
 import type { PageRecord } from "../store.ts";
-import type { PageTree } from "../render.tsx";
+import type { PageTree } from "../page-context.ts";
 import type { ImageValue } from "../media.ts";
 import type { MemberStore } from "../member-store.ts";
 export type UploadMeta = {

package/dist/content/node.d.ts

@@ -1,7 +1,6 @@
 import type { BuilderMap, SectionSchema, StoredValues } from "../schema.ts";
-import type { PairedComponent } from "../pairing.tsx";
-import type { TreeNode } from "../render.tsx";
-export declare function node<F extends BuilderMap, St extends BuilderMap>(section: PairedComponent<SectionSchema<F, St>, F, St>, fields: Partial<StoredValues<F>>, options?: {
+import type { TreeNode } from "../page-context.ts";
+export declare function node<F extends BuilderMap, St extends BuilderMap>(section: SectionSchema<F, St>, fields: Partial<StoredValues<F>>, options?: {
     settings?: Partial<StoredValues<St>>;
     id?: string;
 }): TreeNode;

package/dist/content/node.js

@@ -1,6 +1,7 @@
 import { newNodeId } from "../admin/tree-ops.js";
+import { schemaOnly } from "../registration.js";
 export function node(section, fields, options = {}) {
-    const type = section.schema.name;
+    const type = schemaOnly(section).name;
     return {
         id: options.id ?? newNodeId(type),
         type,

package/dist/crash-message.d.ts

@@ -0,0 +1 @@
+export declare function crashMessage(error: unknown): string;

package/dist/crash-message.js

@@ -0,0 +1,8 @@
+// Why a section crashed, for its placeholder (spec 2026-09-27 section guard §3): the message, or the digest
+// when a production build stripped the message. Shared by the React placeholder and Astro's guard.
+export function crashMessage(error) {
+    const digest = typeof error === "object" && error !== null ? error.digest : undefined;
+    if (typeof digest === "string")
+        return `the server log has the error (digest ${digest})`;
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/css.d.ts

@@ -3,5 +3,9 @@ export declare const CSS_MAX = 4000;
 export declare function cssProblem(css: string): string | null;
 /** The snippet when it is a clean string, else "". */
 export declare function safeCss(css: unknown): string;
+/** A node id as the inside of a CSS attribute-selector string. "<" as its CSS escape: the rule is written inside
+ *  a <style> element, and an id is whatever a request stored, so it must never be able to close that element
+ *  (Astro writes the text raw; React escapes it). */
+export declare const escapeNodeId: (id: string) => string;
 /** Nested under the node's selector — every rule inside reaches the section only. */
 export declare function scopedCss(nodeId: string, css: string): string;

package/dist/css.js

@@ -50,8 +50,11 @@ export function cssProblem(css) {
 export function safeCss(css) {
     return typeof css === "string" && css !== "" && cssProblem(css) === null ? css : "";
 }
+/** A node id as the inside of a CSS attribute-selector string. "<" as its CSS escape: the rule is written inside
+ *  a <style> element, and an id is whatever a request stored, so it must never be able to close that element
+ *  (Astro writes the text raw; React escapes it). */
+export const escapeNodeId = (id) => id.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\3c ");
 /** Nested under the node's selector — every rule inside reaches the section only. */
 export function scopedCss(nodeId, css) {
-    const id = nodeId.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    return `[data-smd-node="${id}"]{${css}}`;
+    return `[data-smd-node="${escapeNodeId(nodeId)}"]{${css}}`;
 }

package/dist/custom/CustomSection.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType, ReactElement } from "react";
-import { SMD_KEY, type SmdInternal } from "../section-wrapper.tsx";
+import { SMD_KEY, type SmdInternal } from "../smd-key.ts";
 import type { StyleProps } from "../styles.ts";
 import { type RichTextElement } from "../richtext-render.tsx";
 export type CustomOptions = {

package/dist/custom/CustomSection.js

@@ -1,19 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Section, SMD_KEY } from "../section-wrapper.js";
+import { Section } from "../section-wrapper.js";
+import { SMD_KEY } from "../smd-key.js";
 import { RichText } from "../richtext-render.js";
 import { FIELD_ATTR, ITEM_ATTR } from "../marks.js";
 import { CUSTOM_NODE_TYPE, DEFAULT_BREAKPOINT } from "./schema.js";
-import { customCss } from "./css.js";
+import { customLayout } from "./layout.js";
 import { RENDER_VIEW } from "../section-guard.js";
-const isRow = (r) => typeof r === "object" && r !== null && Array.isArray(r.columns);
 export function createCustomSection({ RichText: Bound, breakpoint = DEFAULT_BREAKPOINT, elements = [] }) {
     const Body = Bound ?? (({ doc }) => _jsx(RichText, { doc: doc, elements: elements }));
     function CustomSection({ rows, styles }) {
-        const list = Array.isArray(rows) ? rows.filter(isRow) : [];
-        const smd = styles?.[SMD_KEY];
-        const withLayout = smd?.node && list.length > 0
-            ? { ...styles, [SMD_KEY]: { ...smd, layoutCss: customCss(smd.node, list, breakpoint) } }
-            : styles;
+        const { list, styles: withLayout } = customLayout(rows, styles ?? {}, breakpoint);
         return (_jsx(Section, { styles: withLayout, "data-custom": "", children: list.map((row, i) => (_jsx("div", { className: row.reverse ? "smd-row smd-row--reverse" : "smd-row", "data-row": i, [ITEM_ATTR]: `rows.${i}`, children: row.columns.map((doc, j) => (_jsx("div", { className: "smd-col", [FIELD_ATTR]: `columns.${j}`, children: _jsx(Body, { doc: doc }) }, j))) }, i))) }));
     }
     CustomSection.schema = { name: CUSTOM_NODE_TYPE, title: "Custom section" };

package/dist/custom/css.js

@@ -4,12 +4,12 @@
 // reaches it. One rule per row by data-row (nth-child would count the
 // <style> children), one breakpoint that stacks every row.
 import { ALIGN_VALUES, GAP_VALUES, SPAN_TOTAL } from "./schema.js";
+import { escapeNodeId } from "../css.js";
 import { renormalize } from "./rows.js";
 const LENGTH_RE = /^\d+(?:\.\d+)?(?:px|rem|em)$/;
 export const isCssLength = (s) => LENGTH_RE.test(s);
-const escapeId = (id) => id.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 export function customCss(nodeId, rows, breakpoint) {
-    const s = `[data-smd-node="${escapeId(nodeId)}"]`;
+    const s = `[data-smd-node="${escapeNodeId(nodeId)}"]`;
     let css = `${s} .smd-row{display:grid;max-width:var(--smd-width,var(--container,none));margin-inline:auto;padding-inline:var(--smd-gutter,1rem);box-sizing:border-box}` +
         `${s} .smd-row+.smd-row{margin-top:2rem}`;
     rows.forEach((row, i) => {

package/dist/custom/index.d.ts

@@ -1,25 +1,21 @@
-import type { ComponentType } from "react";
 import type { Toolset } from "../toolset.ts";
 import { customSchema } from "./schema.ts";
 export * from "./schema.ts";
 export * from "./rows.ts";
 export * from "./css.ts";
-export { createCustomSection } from "./CustomSection.tsx";
-export type { CustomOptions, CustomSectionProps, CustomSectionComponent } from "./CustomSection.tsx";
-/** `config.custom` / `site.custom` as written (spec 2026-09-14 §6). */
+/** `config.custom` / `site.custom` as written (spec 2026-09-14 §6). The bound RichText is a view: it goes to defineViews and reaches the renderer as an option. */
 export type CustomConfigInput = {
     breakpoint?: string;
     toolset?: Toolset;
-    RichText?: ComponentType<{
-        doc: unknown;
-    }>;
 };
+/** The bound RichText as the config sees it: a framework's component over a document (React: `ComponentType<{ doc }>`). */
+export type RichTextView = (props: {
+    doc: unknown;
+}) => unknown;
 export type ResolvedCustom = {
     breakpoint: string;
     toolset: Toolset;
-    RichText?: ComponentType<{
-        doc: unknown;
-    }>;
+    RichText?: RichTextView;
 };
 /** Every section map the walks build gets the custom schema too (spec 2026-09-14 §6), so a column's images resolve and count as usage. */
 export declare function withCustomSchema<T>(sections: readonly T[], toolset: Toolset): (T | ReturnType<typeof customSchema>)[];

package/dist/custom/index.js

@@ -3,7 +3,6 @@ import { isCssLength } from "./css.js";
 export * from "./schema.js";
 export * from "./rows.js";
 export * from "./css.js";
-export { createCustomSection } from "./CustomSection.js";
 /** Every section map the walks build gets the custom schema too (spec 2026-09-14 §6), so a column's images resolve and count as usage. */
 export function withCustomSchema(sections, toolset) {
     return [...sections, customSchema(toolset)];
@@ -12,5 +11,5 @@ export function resolveCustom(input) {
     const breakpoint = input?.breakpoint ?? DEFAULT_BREAKPOINT;
     if (!isCssLength(breakpoint))
         throw new Error(`smoodly: custom.breakpoint "${breakpoint}" must be a length like "48rem" or "768px".`);
-    return { breakpoint, toolset: customToolset(input?.toolset), ...(input?.RichText ? { RichText: input.RichText } : {}) };
+    return { breakpoint, toolset: customToolset(input?.toolset) };
 }

package/dist/custom/layout.d.ts

@@ -0,0 +1,5 @@
+import type { CustomRow } from "./schema.ts";
+export declare function customLayout(rows: unknown, styles: Record<string, unknown>, breakpoint: string): {
+    list: CustomRow[];
+    styles: Record<string, unknown>;
+};

package/dist/custom/layout.js

@@ -0,0 +1,14 @@
+// The custom section's rows and layout css, decided once for both renderers (CustomSection.tsx and
+// astro/custom.ts): the rows a stored value yields (fail-soft: a malformed value is no rows), and the layout
+// CSS — Smoodly's own, computed from the stored numbers — riding the styles' reserved key as `layoutCss`,
+// which the wrapper emits before the editor's own css so the box still wins. No framework import.
+import { SMD_KEY } from "../smd-key.js";
+import { customCss } from "./css.js";
+const isRow = (r) => typeof r === "object" && r !== null && Array.isArray(r.columns);
+export function customLayout(rows, styles, breakpoint) {
+    const list = Array.isArray(rows) ? rows.filter(isRow) : [];
+    const smd = styles[SMD_KEY];
+    if (!smd?.node || list.length === 0)
+        return { list, styles };
+    return { list, styles: { ...styles, [SMD_KEY]: { ...smd, layoutCss: customCss(smd.node, list, breakpoint) } } };
+}

package/dist/document-stamp.d.ts

@@ -0,0 +1,7 @@
+import type { SiteOptions } from "./site.ts";
+/** Bumped by hand when the assembler's output changes shape; the upgrading guide names each bump. */
+export declare const DOCUMENT_FORMAT = 1;
+/** The parts of the registry that reach a document: what `cacheKey` hashes, minus the presentation. */
+export declare function documentModel(options: SiteOptions): unknown;
+/** `<format>:<model hash>` — what a delivery row's `model` column holds. */
+export declare function documentStamp(options: SiteOptions): string;

package/dist/document-stamp.js

@@ -0,0 +1,48 @@
+// The stamp a delivery row carries (DESIGN §3, the document stamp, 2026-10-08): which document format and
+// which content model built it. Not the cache key: the package version is in that one, not here, because a
+// release that leaves documents alone must leave them alone.
+import { modelKey } from "./model-key.js";
+import { schemaOf } from "./registration.js";
+/** Bumped by hand when the assembler's output changes shape; the upgrading guide names each bump. */
+export const DOCUMENT_FORMAT = 1;
+/** Schema keys that reach the admin only: a change to one leaves every document as it was. */
+const PRESENTATION = new Set(["title", "description", "sample", "icon", "preview", "group", "admin"]);
+/** A field descriptor without the parts that reach the admin only (a hidden condition decides what the editor shows). */
+function fieldModel(field) {
+    if (!field || typeof field !== "object")
+        return field;
+    const { hidden: _hidden, ...rest } = field;
+    return Object.fromEntries(Object.entries(rest).map(([k, v]) => [k, k === "fields" ? fieldsModel(v) : k === "of" ? fieldModel(v) : v]));
+}
+function fieldsModel(fields) {
+    if (!fields || typeof fields !== "object")
+        return fields;
+    return Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, fieldModel(v)]));
+}
+/** A schema without its presentation. */
+function schemaModel(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    return Object.fromEntries(Object.entries(schema)
+        .filter(([k]) => !PRESENTATION.has(k))
+        .map(([k, v]) => [k, k === "fields" || k === "settings" ? fieldsModel(v) : v]));
+}
+/** The parts of the registry that reach a document: what `cacheKey` hashes, minus the presentation. */
+export function documentModel(options) {
+    return {
+        collections: options.collections.map(schemaModel),
+        // A global whole, its presentation dropped: its settings' defaults reach a visual item's document.
+        globals: (options.globals ?? []).map(schemaModel),
+        sections: options.sections.map((x) => schemaModel(schemaOf(x))),
+        elements: (options.elements ?? []).map((x) => schemaModel(schemaOf(x))),
+        pages: options.pages.map((x) => schemaModel(schemaOf(x))),
+        locales: options.locales,
+        homePageSlug: options.homePageSlug,
+        styles: options.styles,
+        custom: options.custom,
+    };
+}
+/** `<format>:<model hash>` — what a delivery row's `model` column holds. */
+export function documentStamp(options) {
+    return `${DOCUMENT_FORMAT}:${modelKey(documentModel(options))}`;
+}

package/dist/entry-page.d.ts

@@ -1,23 +1,8 @@
 import type { ComponentType, ReactElement } from "react";
 import type { CollectionSchema } from "./collections.ts";
-import type { EntryItem } from "./read-shapes.ts";
-import type { Materialize } from "./schema.ts";
-export type EntryPageSchema = {
-    kind: "entryPage";
-    name: string;
-    collection: string;
-};
-/** What an entry page renders: the entry as a read returns it — its path, locale and
- *  locale alternates ride on it (spec 2026-09-29 content API contract §3). */
-export type EntryPageProps<F = Record<string, unknown>> = {
-    entry: EntryItem<F>;
-};
+import type { EntryFields, EntryPageProps, EntryPageSchema } from "./view-props.ts";
+export type { EntryPageSchema, EntryPageProps };
 export type PairedEntryPage = ((props: EntryPageProps) => ReactElement) & {
     schema: EntryPageSchema;
 };
-/** The collection's fields as a read returns them. */
-type Materialized<C extends CollectionSchema<any>> = {
-    [K in keyof NonNullable<C["__entry"]>]: Materialize<NonNullable<C["__entry"]>[K]>;
-};
-export declare function entryPage<C extends CollectionSchema<any>>(collection: C, View: ComponentType<EntryPageProps<Materialized<C>>>): PairedEntryPage;
-export {};
+export declare function entryPage<C extends CollectionSchema<any>>(collection: C, View: ComponentType<EntryPageProps<EntryFields<C>>>): PairedEntryPage;

package/dist/env.js

@@ -25,7 +25,7 @@ function jwtRole(v) {
 export function resolveSmoodlyEnv(env, need = "site") {
     const missing = (need === "admin" ? ADMIN_NEEDS : SITE_NEEDS).filter((name) => !env[name]);
     if (missing.length > 0)
-        throw new Error(`smoodly: set ${missing.join(", ")} in .env.local, or in your host's environment variables (Deploying: ${DEPLOYING}).`);
+        throw new Error(`smoodly: set ${missing.join(", ")} in .env (Astro) or .env.local (Next.js), or in your host's environment variables (Deploying: ${DEPLOYING}).`);
     const secretKey = env.SMOODLY_SECRET_KEY;
     const publishableKey = env.SMOODLY_PUBLISHABLE_KEY ?? "";
     if (secretKey.startsWith("sb_publishable_") || jwtRole(secretKey) === "anon") {

package/dist/global-id.js

@@ -10,8 +10,8 @@
 // No imports — Web Crypto (`globalThis.crypto.subtle`) exists in Node
 // >= 20 and in every browser, so this module carries no node builtin
 // into the package root's graph. It matters because every scaffolded
-// section does `import { f, smoodly } from "smoodly"`, and a "use client"
-// section's browser build would fail on `node:crypto`.
+// component does `import { smoodly } from "smoodly/react"`, which re-exports
+// the root, and a "use client" section's browser build would fail on `node:crypto`.
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /** The namespace's 16 raw bytes — RFC 4122 hashes the bytes, not the text. */
 function uuidBytes(uuid) {

package/dist/global.d.ts

@@ -1,6 +1,5 @@
 import type { CollectionSchema } from "./collections.ts";
 import type { Descriptor } from "./fields.ts";
-import type { PairedComponent } from "./pairing.tsx";
 import type { BuilderMap, SectionSchema, Values } from "./schema.ts";
 import type { GlobalItem, VisualGlobalItem } from "./read-shapes.ts";
 /** The reserved tree node type of a placement. */
@@ -24,6 +23,9 @@ export type GlobalSchema<V = Record<string, unknown>, N extends string = string>
     /** The section's settings descriptors (empty for an object item). */
     settings: Record<string, Descriptor>;
     sample?: Record<string, unknown>;
+    /** Every page renders it (the header, the footer): the page's lookup brings it along, so the layout's read costs
+     *  no call (decided 2026-10-08). Absent: placed in zones or read by one view, fetched only where it is read. */
+    layout?: true;
     /** phantom: what getGlobal returns */
     readonly __value?: V;
 };
@@ -42,13 +44,14 @@ export declare function globalLink(node: {
 type GlobalInput<N extends string = string> = {
     name: N;
     title: string;
+    layout?: boolean;
 };
 export declare function globalItem<F extends BuilderMap, const N extends string = string>(input: GlobalInput<N> & {
     fields: F;
     section?: undefined;
 }): GlobalSchema<GlobalItem<Values<F>>, N>;
 export declare function globalItem<F extends BuilderMap, St extends BuilderMap, const N extends string = string>(input: GlobalInput<N> & {
-    section: PairedComponent<SectionSchema<F, St>, F, St>;
+    section: SectionSchema<F, St>;
     fields?: undefined;
 }): GlobalSchema<VisualGlobalItem<Values<F>, Values<St>>, N>;
 export {};

package/dist/global.js

@@ -1,3 +1,4 @@
+import { schemaOnly } from "./registration.js";
 /** The reserved tree node type of a placement. */
 export const GLOBAL_NODE_TYPE = "global";
 /** The reserved keys a visual item's settings, styles steps and css live under in its row (spec 2026-09-14 §8). */
@@ -31,8 +32,9 @@ export function globalItem(input) {
     if ((input.fields === undefined) === (input.section === undefined)) {
         throw new Error(`smoodly: global item "${input.name}" must declare exactly one of \`section\` or \`fields\`.`);
     }
-    const fields = input.section
-        ? input.section.schema.fields
+    const section = input.section ? schemaOnly(input.section) : undefined;
+    const fields = section
+        ? section.fields
         : Object.fromEntries(Object.entries(input.fields).map(([k, b]) => [k, b.descriptor]));
     for (const key of RESERVED_KEYS) {
         if (Object.prototype.hasOwnProperty.call(fields, key)) {
@@ -44,8 +46,9 @@ export function globalItem(input) {
         name: input.name,
         title: input.title,
         fields,
-        settings: input.section ? input.section.schema.settings : {},
-        ...(input.section ? { section: input.section.schema.name } : {}),
-        ...(input.section?.schema.sample ? { sample: input.section.schema.sample } : {}),
+        settings: section ? section.settings : {},
+        ...(section ? { section: section.name } : {}),
+        ...(section?.sample ? { sample: section.sample } : {}),
+        ...(input.layout ? { layout: true } : {}),
     };
 }

package/dist/image/next-config.d.ts

@@ -12,4 +12,7 @@ export type SmoodlyImagesConfig = {
  * Supabase stack answers on. A public hostname that happens to resolve
  * privately (a Docker alias) is not detected; set the flag by hand then. */
 export declare function isPrivateHost(hostname: string): boolean;
+/** The Supabase host's public media path as a remote pattern. Defined here, not in remote-pattern.ts: this
+ *  entry loads in plain Node and imports nothing; remote-pattern.ts re-exports it for the Astro side. */
+export declare function mediaRemotePattern(url: string): RemotePattern;
 export declare function smoodlyImages(url?: string | undefined): SmoodlyImagesConfig;