smoodly 0.0.16 → 0.0.17

package/dist/admin/forms/tabs.d.ts

@@ -1,20 +1,26 @@
 import type { AdminField } from "../serialize.ts";
-export type TabName = "Content" | "Styles" | "Media" | "Meta";
+export type TabName = "Content" | "Settings";
+export type GroupTitle = "Spacing & layout" | "Advanced";
 export type TabEntry = {
     key: string;
-    ns: "fields" | "styles" | "meta";
+    ns: "fields" | "settings" | "styles" | "css";
     descriptor: AdminField;
 };
-/** Anything with namespaced descriptors: a section, or a shared item (fields + styles, no meta). */
+export type Group = {
+    title?: GroupTitle;
+    entries: TabEntry[];
+};
+/** A section, an element (no styles, no css) or a global item. */
 export type FieldsHolder = {
     fields: Record<string, AdminField>;
+    settings?: Record<string, AdminField>;
     styles?: Record<string, AdminField>;
-    meta?: Record<string, AdminField>;
+    css?: boolean;
 };
-export declare function tabsFor(section: FieldsHolder): {
+export declare const CSS_DESCRIPTOR: AdminField;
+export declare function tabsFor(holder: FieldsHolder): {
     tab: TabName;
-    entries: TabEntry[];
+    groups: Group[];
 }[];
-/** The tab holding a content field, by its dotted path's top-level key — a canvas
- *  click on a marked image reveals it on Media, where the projection put it. */
-export declare function tabOf(section: FieldsHolder, path: string): TabName | undefined;
+/** The tab a dotted path belongs to, by its top-level key — a canvas click reveals it there. */
+export declare function tabOf(holder: FieldsHolder, path: string): TabName | undefined;

package/dist/admin/forms/tabs.js

@@ -1,26 +1,22 @@
-const MEDIA_TYPES = new Set(["image", "video", "file"]);
-const TAB_BY_NS = {
-    fields: "Content", styles: "Styles", meta: "Meta",
-};
-const TAB_BY_OVERRIDE = {
-    content: "Content", styles: "Styles", media: "Media", meta: "Meta",
-};
-export function tabsFor(section) {
-    const buckets = { Content: [], Styles: [], Media: [], Meta: [] };
-    for (const ns of ["fields", "styles", "meta"]) {
-        for (const [key, descriptor] of Object.entries(section[ns] ?? {})) {
-            const override = typeof descriptor.tab === "string" ? TAB_BY_OVERRIDE[descriptor.tab] : undefined;
-            const tab = override ?? (MEDIA_TYPES.has(descriptor.type) ? "Media" : TAB_BY_NS[ns]);
-            buckets[tab].push({ key, ns, descriptor });
-        }
-    }
-    return ["Content", "Styles", "Media", "Meta"]
-        .filter((tab) => buckets[tab].length > 0)
-        .map((tab) => ({ tab, entries: buckets[tab] }));
+export const CSS_DESCRIPTOR = { type: "css" };
+const entries = (ns, map) => Object.entries(map ?? {}).map(([key, descriptor]) => ({ key, ns, descriptor }));
+export function tabsFor(holder) {
+    const content = [{ entries: entries("fields", holder.fields) }];
+    const settings = [
+        { entries: entries("settings", holder.settings) },
+        { title: "Spacing & layout", entries: entries("styles", holder.styles) },
+        { title: "Advanced", entries: holder.css === true ? [{ key: "css", ns: "css", descriptor: CSS_DESCRIPTOR }] : [] },
+    ];
+    return [["Content", content], ["Settings", settings]]
+        .map(([tab, groups]) => ({ tab, groups: groups.filter((g) => g.entries.length > 0) }))
+        .filter((t) => t.groups.length > 0);
 }
-/** The tab holding a content field, by its dotted path's top-level key — a canvas
- *  click on a marked image reveals it on Media, where the projection put it. */
-export function tabOf(section, path) {
+/** The tab a dotted path belongs to, by its top-level key — a canvas click reveals it there. */
+export function tabOf(holder, path) {
     const key = path.split(".")[0];
-    return tabsFor(section).find((t) => t.entries.some((e) => e.ns === "fields" && e.key === key))?.tab;
+    if (key in holder.fields)
+        return "Content";
+    if (key in (holder.settings ?? {}) || key in (holder.styles ?? {}) || (key === "css" && holder.css === true))
+        return "Settings";
+    return undefined;
 }

package/dist/admin/forms/useRichtextEditor.js

@@ -135,7 +135,14 @@ export function useRichtextEditor({ value, toolset, onChange, contentClass, onEs
         if (!editor || value === emitted.current)
             return;
         emitted.current = value;
-        editor.commands.setContent(isDoc(value) ? value : EMPTY, { emitUpdate: false });
+        // TipTap's React node views (the image and element cards) flush React synchronously inside
+        // setContent, which React forbids from a lifecycle effect ("flushSync was called from inside a
+        // lifecycle method"). One microtask later React is idle; a widget unmounted meanwhile is skipped.
+        const next = isDoc(value) ? value : EMPTY;
+        queueMicrotask(() => {
+            if (!editor.isDestroyed)
+                editor.commands.setContent(next, { emitUpdate: false });
+        });
     }, [editor, value]);
     const active = useEditorState({
         editor,

package/dist/admin/global-items.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { Descriptor } from "../fields.ts";
+import type { EntryRecord, EntryStore } from "../entry-store.ts";
+import { type GlobalSchema } from "../global.ts";
+/** The merged fields a fresh item starts from: sampled field values, and
+ *  for a visual item `$settings` = the section's settings defaults with the
+ *  sample's settings values on top. Unsampled fields stay absent. */
+export declare function initialGlobalFields(item: GlobalSchema, settingsDescriptors: Record<string, Descriptor>): Record<string, unknown>;
+export declare function ensureGlobalItems(entries: EntryStore, config: ResolvedConfig): Promise<Record<string, EntryRecord>>;

package/dist/admin/{shared-items.js → global-items.js}

@@ -1,8 +1,9 @@
-import { STYLES_KEY } from "../shared.js";
+import { SETTINGS_KEY } from "../global.js";
+import { sectionSettings } from "./serialize.js";
 /** The merged fields a fresh item starts from: sampled field values, and
- *  for a visual item `$styles` = the resolved style defaults with the
- *  sample's style values on top. Unsampled fields stay absent. */
-export function initialSharedFields(item, resolvedStyles) {
+ *  for a visual item `$settings` = the section's settings defaults with the
+ *  sample's settings values on top. Unsampled fields stay absent. */
+export function initialGlobalFields(item, settingsDescriptors) {
     const out = {};
     for (const key of Object.keys(item.fields)) {
         const sampled = item.sample?.[key];
@@ -10,25 +11,25 @@ export function initialSharedFields(item, resolvedStyles) {
             out[key] = sampled;
     }
     if (item.section !== undefined) {
-        const styles = {};
-        for (const [key, d] of Object.entries(resolvedStyles)) {
+        const settings = {};
+        for (const [key, d] of Object.entries(settingsDescriptors)) {
             const value = item.sample?.[key] ?? d.default;
             if (value !== undefined)
-                styles[key] = value;
+                settings[key] = value;
         }
-        out[STYLES_KEY] = styles;
+        out[SETTINGS_KEY] = settings;
     }
     return out;
 }
-export async function ensureSharedItems(entries, config) {
+export async function ensureGlobalItems(entries, config) {
     const { default: def, supported } = config.locales;
     const out = {};
-    for (const item of config.registry.shared ?? []) {
+    for (const item of config.registry.globals ?? []) {
         let [record] = await entries.list(item.name);
         if (!record) {
             try {
-                const styles = item.section !== undefined ? config.resolvedStyles(item.section) : {};
-                record = await entries.create(item.name, initialSharedFields(item, styles), { locale: def });
+                const settings = item.section !== undefined ? sectionSettings(config, item.section) : {};
+                record = await entries.create(item.name, initialGlobalFields(item, settings), { locale: def });
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
@@ -37,7 +38,7 @@ export async function ensureSharedItems(entries, config) {
                 if (message.includes("it is a singleton"))
                     [record] = await entries.list(item.name);
                 else
-                    console.warn(`smoodly: could not materialize shared item "${item.name}": ${message}`);
+                    console.warn(`smoodly: could not materialize global item "${item.name}": ${message}`);
                 if (!record)
                     continue;
             }
@@ -51,11 +52,11 @@ export async function ensureSharedItems(entries, config) {
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
                 if (!message.includes("already exists in locale")) {
-                    console.warn(`smoodly: could not materialize shared item "${item.name}" in "${locale}": ${message}`);
+                    console.warn(`smoodly: could not materialize global item "${item.name}" in "${locale}": ${message}`);
                 }
             }
         }
-        // Every shared item is versioned (decided 2026-09-13). A row published before that has
+        // Every global item is versioned (decided 2026-09-13). A row published before that has
         // no pointers, so its next save would go live: publish it once more here, which snapshots
         // what is live and points both pointers at it. Idempotent — pointed rows are skipped.
         for (const locale of supported) {
@@ -66,7 +67,7 @@ export async function ensureSharedItems(entries, config) {
                 record = await entries.setStatus(item.name, record.id, locale, "published");
             }
             catch (e) {
-                console.warn(`smoodly: could not version shared item "${item.name}" in "${locale}": ${e instanceof Error ? e.message : String(e)}`);
+                console.warn(`smoodly: could not version global item "${item.name}" in "${locale}": ${e instanceof Error ? e.message : String(e)}`);
             }
         }
         out[item.name] = record;

package/dist/admin/index.d.ts

@@ -1,11 +1,11 @@
-export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, SharedListItem, SharedGetResult, AssetUsageItem } from "./ops.ts";
+export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, GlobalListItem, GlobalGetResult, AssetUsageItem } from "./ops.ts";
 export { createAdminOps, runAdminOp, type AdminEffects } from "./ops-impl.ts";
 export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes, type FixedNode } from "./fixed-nodes.ts";
-export { ensureSharedItems, initialSharedFields } from "./shared-items.ts";
+export { ensureGlobalItems, initialGlobalFields } from "./global-items.ts";
 export { makeClientOps } from "./client-ops.ts";
 export { gateAdminOp, type AdminAuth } from "./auth.ts";
 export { supabaseAdminAuth } from "./supabase-auth.ts";
 export { serializeAdminConfig } from "./serialize.ts";
-export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminShared, AdminField } from "./serialize.ts";
+export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminGlobal, AdminField } from "./serialize.ts";
 export * from "./tree-ops.ts";
 export { validateFields, type FieldError } from "./validate.ts";

package/dist/admin/index.js

@@ -1,6 +1,6 @@
 export { createAdminOps, runAdminOp } from "./ops-impl.js";
 export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes } from "./fixed-nodes.js";
-export { ensureSharedItems, initialSharedFields } from "./shared-items.js";
+export { ensureGlobalItems, initialGlobalFields } from "./global-items.js";
 export { makeClientOps } from "./client-ops.js";
 export { gateAdminOp } from "./auth.js";
 export { supabaseAdminAuth } from "./supabase-auth.js";

package/dist/admin/ops-impl.js

@@ -1,10 +1,12 @@
 import { entryFieldsIn, entryTitleIn } from "../entry-store.js";
 import { ASSET_COLLECTION } from "../media.js";
 import { BASE } from "./shell/base.js";
-import { affectedTargets, collectionTag, entryTag, pageTag, pagesTreeTag, sharedTag } from "../revalidate.js";
+import { affectedTargets, collectionTag, entryTag, pageTag, pagesTreeTag, globalTag } from "../revalidate.js";
 import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
-import { ensureSharedItems } from "./shared-items.js";
-import { validateFields } from "./validate.js";
+import { ensureGlobalItems } from "./global-items.js";
+import { validateCustomNode, validateFields, validateNode } from "./validate.js";
+import { CUSTOM_NODE_TYPE, customSchema } from "../custom/index.js";
+import { SETTINGS_KEY, CSS_KEY } from "../global.js";
 import { withDefaults } from "../field-defaults.js";
 import { elementSchemas } from "../richtext-walk.js";
 const ok = (data) => ({ ok: true, data });
@@ -96,11 +98,12 @@ export function createAdminOps(deps) {
     const by = deps.actor?.email ?? undefined;
     const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
     // Element nodes inside richtext validate against these (spec 2026-09-08 block nodes §2).
-    const elementDescs = elementSchemas((config.registry.elements ?? []).map((e) => ({ name: e.schema.name, fields: e.schema.fields ?? {}, styles: e.schema.styles })));
-    const sectionFields = (type) => config.registry.sections?.find((s) => s.schema.name === type)?.schema;
-    const sharedItem = (name) => config.registry.shared?.find((s) => s.name === name) ?? null;
+    const elementDescs = elementSchemas((config.registry.elements ?? []).map((e) => ({ name: e.schema.name, fields: e.schema.fields ?? {}, settings: e.schema.settings })));
+    // The custom section (spec 2026-09-14 §6) validates like a section, over its own schema.
+    const sectionFields = (type) => (type === CUSTOM_NODE_TYPE ? customSchema(config.custom.toolset) : config.registry.sections?.find((s) => s.schema.name === type)?.schema);
+    const globalItem = (name) => config.registry.globals?.find((s) => s.name === name) ?? null;
     /** One row per registration; null when materialization could not create it. */
-    const sharedRecord = async (name) => (await entries.list(name))[0] ?? null;
+    const globalRecord = async (name) => (await entries.list(name))[0] ?? null;
     const fanOut = async (entryId) => {
         if (!effects?.revalidate)
             return;
@@ -109,28 +112,28 @@ export function createAdminOps(deps) {
             effects.revalidate(entryTag(id));
         for (const id of pageIds)
             effects.revalidate(pageTag(id));
-        // A shared item's row is an entry like any other: when the item
+        // A global item's row is an entry like any other: when the item
         // itself changes OR when something it REFERENCES does, the unit
-        // `getSmoodlyShared` caches under `shared:<name>` is stale too — and
+        // `getSmoodlyGlobal` caches under `global:<name>` is stale too — and
         // that unit is a layout, on every page. `affectedTargets` returns row
         // ids, so resolve name → row id here. Once per fan-out, not memoized
         // per ops instance: a row can be materialized between two calls, and
         // an entry write is rare enough that one `entries.list` per
         // registration beats reasoning about a stale cache. Last, so the
         // existing entry-then-page order is untouched.
-        const registered = config.registry.shared ?? [];
+        const registered = config.registry.globals ?? [];
         if (registered.length === 0)
             return;
         const touched = new Set(entryIds);
         for (const item of registered) {
             const row = (await entries.list(item.name))[0];
             if (row && touched.has(row.id))
-                effects.revalidate(sharedTag(item.name));
+                effects.revalidate(globalTag(item.name));
         }
     };
     /** An asset's metadata (alt, title, caption, credit) is read wherever media
      *  resolves (spec 2026-09-08 §9): the entry and page units that reference the
-     *  asset, directly or through an entry, the shared items among those rows,
+     *  asset, directly or through an entry, the global items among those rows,
      *  and the list units of every referencing entry's collection. The walk is
      *  the entry fan-out's, seeded with the asset's id — which is no entry, so
      *  it gets no tag of its own. */
@@ -144,10 +147,10 @@ export function createAdminOps(deps) {
         for (const id of pageIds)
             effects.revalidate(pageTag(id));
         const touched = new Set(users);
-        for (const item of config.registry.shared ?? []) {
+        for (const item of config.registry.globals ?? []) {
             const row = (await entries.list(item.name))[0];
             if (row && touched.has(row.id))
-                effects.revalidate(sharedTag(item.name));
+                effects.revalidate(globalTag(item.name));
         }
         for (const c of config.registry.collections ?? []) {
             for (const id of users) {
@@ -206,9 +209,9 @@ export function createAdminOps(deps) {
                 return { title: sourceId, href: null };
             return { title: record.locales[def]?.title ?? Object.values(record.locales)[0]?.title ?? sourceId, href: `${BASE}/pages/${sourceId}` };
         }
-        for (const item of config.registry.shared ?? []) {
+        for (const item of config.registry.globals ?? []) {
             if (await entries.get(item.name, sourceId))
-                return { title: item.title, href: `${BASE}/shared/${encodeURIComponent(item.name)}` };
+                return { title: item.title, href: `${BASE}/globals/${encodeURIComponent(item.name)}` };
         }
         for (const c of config.registry.collections ?? []) {
             const record = await entries.get(c.name, sourceId);
@@ -323,7 +326,11 @@ export function createAdminOps(deps) {
                         const schema = sectionFields(node.type);
                         if (!schema?.fields)
                             continue;
-                        for (const fe of validateFields(node.fields ?? {}, schema.fields, elementDescs)) {
+                        // Fields, settings (prefixed) and the css snippet (spec 2026-09-14 §3, §4); a custom section adds its row structure (§6).
+                        const errors = node.type === CUSTOM_NODE_TYPE
+                            ? validateCustomNode(node, schema.fields, elementDescs)
+                            : validateNode(node, { fields: schema.fields, settings: schema.settings }, elementDescs);
+                        for (const fe of errors) {
                             fieldErrors.push({ field: `${node.id}.${fe.field}`, message: fe.message });
                         }
                     }
@@ -642,22 +649,22 @@ export function createAdminOps(deps) {
                 return ok(entry);
             }),
         },
-        shared: {
+        globals: {
             list: () => guard(async () => {
-                const records = await ensureSharedItems(entries, config);
-                return ok((config.registry.shared ?? []).flatMap((s) => (records[s.name] ? [{ name: s.name, record: records[s.name] }] : [])));
+                const records = await ensureGlobalItems(entries, config);
+                return ok((config.registry.globals ?? []).flatMap((s) => (records[s.name] ? [{ name: s.name, record: records[s.name] }] : [])));
             }),
             get: (name, locale) => guard(async () => {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                const item = sharedItem(name);
+                const item = globalItem(name);
                 if (!item)
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                await ensureSharedItems(entries, config);
-                const record = await sharedRecord(name);
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                await ensureGlobalItems(entries, config);
+                const record = await globalRecord(name);
                 if (!record?.locales[locale])
-                    return err("not_found", `smoodly: shared item "${name}" does not exist in locale "${locale}".`);
+                    return err("not_found", `smoodly: global item "${name}" does not exist in locale "${locale}".`);
                 const usage = await entries.referencesTo(name, record.id);
                 return ok({ name, record, locale, fields: entryFieldsIn(record, locale), usage });
             }),
@@ -665,14 +672,14 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                const item = sharedItem(name);
+                const item = globalItem(name);
                 if (!item)
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 const saved = await entries.update(name, record.id, locale, fields, by);
-                // fanOut expires `shared:<name>` itself — this row IS the item's.
+                // fanOut expires `global:<name>` itself — this row IS the item's.
                 await fanOut(record.id);
                 return ok(saved);
             }),
@@ -680,17 +687,21 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                const item = sharedItem(name);
+                const item = globalItem(name);
                 if (!item)
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 if (status === "published") {
                     // A draft may be incomplete; what goes live may not (spec 2026-09-14 §2).
                     if (!record.locales[locale])
-                        return err("not_found", `smoodly: shared item "${name}" does not exist in locale "${locale}".`);
-                    const fieldErrors = validateFields(entryFieldsIn(record, locale), item.fields, elementDescs);
+                        return err("not_found", `smoodly: global item "${name}" does not exist in locale "${locale}".`);
+                    // A visual item validates like a tree node: its fields, its section's settings under `$settings`
+                    // (prefixed `settings.`), its `$css` (spec 2026-09-14 §3, §4).
+                    const { [SETTINGS_KEY]: settings, [CSS_KEY]: css, ...fields } = entryFieldsIn(record, locale);
+                    const settingsDescs = item.section !== undefined ? sectionFields(item.section)?.settings : undefined;
+                    const fieldErrors = validateNode({ fields, settings: settings !== null && typeof settings === "object" ? settings : {}, css }, { fields: item.fields, settings: settingsDescs }, elementDescs);
                     if (fieldErrors.length > 0)
                         return err("validation", "Some fields need attention.", fieldErrors);
                 }
@@ -703,11 +714,11 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                if (!sharedItem(name))
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                if (!globalItem(name))
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 const restored = await entries.discardDraft(name, record.id, locale, by);
                 await fanOut(record.id);
                 return ok(restored);
@@ -716,22 +727,22 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                if (!sharedItem(name))
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                if (!globalItem(name))
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 return ok((await entries.listVersions(name, record.id, locale)).map(summary));
             }),
             getVersion: (name, versionId) => guard(async () => {
-                if (!sharedItem(name))
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                if (!globalItem(name))
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 const version = typeof versionId === "string" ? await entries.getVersion(name, versionId) : null;
                 if (!version || version.entryId !== record.id) {
-                    return err("not_found", `smoodly: no version "${String(versionId)}" of shared item "${name}".`);
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of global item "${name}".`);
                 }
                 return ok({ ...summary(version), fields: version.fields });
             }),
@@ -739,14 +750,14 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                if (!sharedItem(name))
-                    return err("not_found", `smoodly: no shared item named "${name}".`);
-                const record = await sharedRecord(name);
+                if (!globalItem(name))
+                    return err("not_found", `smoodly: no global item named "${name}".`);
+                const record = await globalRecord(name);
                 if (!record)
-                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                    return err("not_found", `smoodly: global item "${name}" is not materialized — open Globals first.`);
                 const version = typeof versionId === "string" ? await entries.getVersion(name, versionId) : null;
                 if (!version || version.entryId !== record.id || version.locale !== locale) {
-                    return err("not_found", `smoodly: no version "${String(versionId)}" of shared item "${name}" in ${locale}.`);
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of global item "${name}" in ${locale}.`);
                 }
                 const restored = await entries.restore(name, record.id, locale, versionId, by);
                 await fanOut(record.id);

package/dist/admin/ops.d.ts

@@ -60,16 +60,16 @@ export type EntryGetResult = {
     /** The locales the PARENT exists in (every supported locale for a root) — the form disables the rest with a reason. */
     parentLocales: string[];
 };
-export type SharedListItem = {
+export type GlobalListItem = {
     name: string;
     record: EntryRecord;
 };
-export type SharedGetResult = {
+export type GlobalGetResult = {
     name: string;
     /** The node with ALL its locale rows (every supported one, by construction). */
     record: EntryRecord;
     locale: string;
-    /** That locale's merged draft fields — a visual item's styles under `$styles`. */
+    /** That locale's merged draft fields — a visual item's settings under `$settings`. */
     fields: Record<string, unknown>;
     /** Who links it: "used on N pages". */
     usage: EntryUsage[];
@@ -156,10 +156,10 @@ export type AdminOps = {
         /** The snapshot becomes the draft (§6); `not_found` for a foreign version. Fans out like a save. */
         restore(collection: string, id: string, locale: string, versionId: string): Promise<OpResult<EntryRecord>>;
     };
-    shared: {
+    globals: {
         /** Materializes every registered item in every supported locale, then lists them in registry order. */
-        list(): Promise<OpResult<SharedListItem[]>>;
-        get(name: string, locale: string): Promise<OpResult<SharedGetResult>>;
+        list(): Promise<OpResult<GlobalListItem[]>>;
+        get(name: string, locale: string): Promise<OpResult<GlobalGetResult>>;
         save(name: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
         setStatus(name: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
         /** The item's live row back to its published snapshot (§4); `blocked` before the first publish. */

package/dist/admin/serialize.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedConfig } from "../config.ts";
+import type { Descriptor } from "../fields.ts";
 import type { ZonePolicy } from "../zones.ts";
 export type AdminField = Record<string, unknown> & {
     type: string;
@@ -14,8 +15,11 @@ export type AdminSection = {
     icon?: string;
     description?: string;
     fields: Record<string, AdminField>;
+    settings: Record<string, AdminField>;
+    /** Smoodly's styles set after the schema's toggle (spec 2026-09-14 §2); `{}` for `styles: false`. */
     styles: Record<string, AdminField>;
-    meta: Record<string, AdminField>;
+    /** The custom-CSS box exists for this section: the project flag, unless the schema says `css: false` (spec 2026-09-14 §4). */
+    css: boolean;
     sample?: Record<string, unknown>;
 };
 export type AdminCollection = {
@@ -43,17 +47,19 @@ export type AdminPageTemplate = {
     /** `meta: { seo: true }` — the SEO & Social tab exists for this template. */
     seo: boolean;
 };
-export type AdminShared = {
+export type AdminGlobal = {
     name: string;
     title: string;
     /** The section a visual item renders through; absent = an object item. */
     section?: string;
     fields: Record<string, AdminField>;
-    /** Resolved (the config's standard set merged in) for a visual item; empty for an object item. */
+    /** The section's settings, styles set and css flag for a visual item; `{}` / `{}` / `false` for an object item. */
+    settings: Record<string, AdminField>;
     styles: Record<string, AdminField>;
+    css: boolean;
 };
-/** A registered Element (spec 2026-09-08 block nodes §1): a section shape plus its contexts. */
-export type AdminElement = AdminSection & {
+/** A registered Element (spec 2026-09-08 block nodes §1): a section shape plus its contexts — no styles, no css. */
+export type AdminElement = Omit<AdminSection, "styles" | "css"> & {
     contexts: string[];
 };
 export type AdminRegistry = {
@@ -61,11 +67,15 @@ export type AdminRegistry = {
     elements: AdminElement[];
     collections: AdminCollection[];
     pages: AdminPageTemplate[];
-    shared: AdminShared[];
+    globals: AdminGlobal[];
+    /** The custom section (spec 2026-09-14 §6) as one synthetic section: its rows descriptor, the full styles set, the project css flag. */
+    custom: AdminSection;
     locales: {
         default: string;
         supported: string[];
     };
+    /** The project's custom-CSS flag (spec 2026-09-14 §4). */
+    css: boolean;
     /** Which slug the site root serves. */
     homePageSlug: string;
     /** How deep editors may nest pages; 1 = flat. */
@@ -76,4 +86,6 @@ export type AdminRegistry = {
         accept: string[];
     };
 };
+/** A registered section's settings descriptors — what a visual global's form shows (spec 2026-09-14 §3). */
+export declare function sectionSettings(config: ResolvedConfig, name: string): Record<string, Descriptor>;
 export declare function serializeAdminConfig(config: ResolvedConfig): AdminRegistry;