smoodly 0.0.16 → 0.0.17

package/dist/entry-store.d.ts

@@ -1,5 +1,5 @@
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
-import type { SharedSchema } from "./shared.ts";
+import type { GlobalSchema } from "./global.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
@@ -82,7 +82,7 @@ export type AddEntryLocaleOptions = {
 export type EntryStoreOptions = {
     paths?: PathIndex;
     locales?: LocaleSet;
-    shared?: SharedSchema[];
+    globals?: GlobalSchema[];
     /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
     elements?: SectionLike[];
 };
@@ -154,8 +154,8 @@ export interface EntryStore {
     pathsOf(collection: string, id: string): Promise<Record<string, string>>;
 }
 export declare function schemaOf(collections: CollectionSchema<any>[], name: string): CollectionSchema<any>;
-/** A shared item is a collection with exactly one entry (spec 2026-09-07). */
-export declare const isSharedSchema: (schema: CollectionSchema<any>) => boolean;
+/** A global item is a collection with exactly one entry (spec 2026-09-07). */
+export declare const isGlobalSchema: (schema: CollectionSchema<any>) => boolean;
 export declare const DEFAULT_ENTRY_LOCALES: LocaleSet;
 export declare const entryErrors: {
     notFound: (collection: string, id: string) => Error;

package/dist/entry-store.js

@@ -13,7 +13,7 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
 import { MemoryPathIndex } from "./path-index.js";
-import { sharedEntryId } from "./shared-id.js";
+import { globalEntryId } from "./global-id.js";
 import { DEFAULT_SPACE_ID } from "./sql-space.js";
 import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, } from "./paths.js";
 /** The field types whose value is an array: a scalar `where` on one is
@@ -40,8 +40,8 @@ export function schemaOf(collections, name) {
         throw new Error(`smoodly: no collection named "${name}".`);
     return schema;
 }
-/** A shared item is a collection with exactly one entry (spec 2026-09-07). */
-export const isSharedSchema = (schema) => schema.kind === "shared";
+/** A global item is a collection with exactly one entry (spec 2026-09-07). */
+export const isGlobalSchema = (schema) => schema.kind === "global";
 let counter = 0;
 const uid = (prefix) => `${prefix}-${++counter}-${Date.now().toString(36)}`;
 export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
@@ -62,11 +62,11 @@ export const entryErrors = {
     lastLocale: (id) => new Error(`smoodly: entry "${id}" must exist in at least one locale — delete the entry instead.`),
     localeInUse: (locale, titles) => new Error(`smoodly: child entries still exist in locale "${locale}" — remove it from ${titles.map((t) => `"${t}"`).join(", ")} first.`),
     moveLocales: (locale) => new Error(`smoodly: the destination parent does not exist in locale "${locale}" — the entry cannot move under it.`),
-    // Shared items (spec 2026-09-07 §3): one row, no URL, every locale, code-owned.
-    singleton: (name) => new Error(`smoodly: shared item "${name}" already exists — it is a singleton.`),
-    owned: (name, verb) => new Error(`smoodly: shared item "${name}" is owned by code — ${verb}.`),
-    noSlug: (name) => new Error(`smoodly: shared item "${name}" has no URL — it cannot take a slug.`),
-    everyLocale: (name) => new Error(`smoodly: shared item "${name}" exists in every locale — it cannot be removed from one.`),
+    // Global items (spec 2026-09-07 §3): one row, no URL, every locale, code-owned.
+    singleton: (name) => new Error(`smoodly: global item "${name}" already exists — it is a singleton.`),
+    owned: (name, verb) => new Error(`smoodly: global item "${name}" is owned by code — ${verb}.`),
+    noSlug: (name) => new Error(`smoodly: global item "${name}" has no URL — it cannot take a slug.`),
+    everyLocale: (name) => new Error(`smoodly: global item "${name}" exists in every locale — it cannot be removed from one.`),
     foreignVersion: (collection, id, locale, versionId) => new Error(`smoodly: "${versionId}" is not a version of entry "${id}" in "${collection}", locale "${locale}".`),
 };
 /** The keys a locale row owns: every field with .localized(), except
@@ -167,7 +167,7 @@ export class MemoryEntryStore {
         this.byId = (id) => this.entries.get(id);
         this.paths = options.paths ?? new MemoryPathIndex();
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
-        this.schemas = [...collections, ...(options.shared ?? [])];
+        this.schemas = [...collections, ...(options.globals ?? [])];
         this.elements = options.elements;
     }
     schema(collection) {
@@ -304,7 +304,7 @@ export class MemoryEntryStore {
         const schema = this.schema(collection);
         assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
-        if (isSharedSchema(schema)) {
+        if (isGlobalSchema(schema)) {
             if ([...this.entries.values()].some((e) => e.collection === collection))
                 throw entryErrors.singleton(collection);
             if (slugOf(fields) !== null)
@@ -316,10 +316,10 @@ export class MemoryEntryStore {
         this.assertSiblingSlug(collection, parentId, options.locale, slug);
         const now = Date.now();
         const entry = {
-            // A shared item's id is derived, not minted (spec 2026-09-07 §10):
+            // A global item's id is derived, not minted (spec 2026-09-07 §10):
             // the same uuid v5 the Supabase adapter computes, so self-host and
             // cloud agree on the row a materialization would create.
-            id: isSharedSchema(schema) ? await sharedEntryId(DEFAULT_SPACE_ID, collection) : uid("entry"),
+            id: isGlobalSchema(schema) ? await globalEntryId(DEFAULT_SPACE_ID, collection) : uid("entry"),
             collection, parentId, fields: shared,
             locales: {
                 [options.locale]: {
@@ -393,7 +393,7 @@ export class MemoryEntryStore {
         const row = entryLocaleRow(entry, locale);
         this.ensureLiveSnapshot(entry, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
-        if (isSharedSchema(schema) && slug !== null)
+        if (isGlobalSchema(schema) && slug !== null)
             throw entryErrors.noSlug(collection);
         this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
         const before = { fields: entry.fields, row: { ...row } };
@@ -479,7 +479,7 @@ export class MemoryEntryStore {
     }
     async removeLocale(collection, id, locale) {
         const schema = this.schema(collection);
-        if (isSharedSchema(schema))
+        if (isGlobalSchema(schema))
             throw entryErrors.everyLocale(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
@@ -533,7 +533,7 @@ export class MemoryEntryStore {
         return v ? structuredClone(v) : null;
     }
     async move(collection, id, to) {
-        if (isSharedSchema(this.schema(collection)))
+        if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no tree position");
         const entry = this.must(collection, id);
         const subtree = this.subtree(entry);
@@ -572,7 +572,7 @@ export class MemoryEntryStore {
         const entry = this.row(collection, id);
         if (!entry)
             return;
-        if (isSharedSchema(this.schema(collection)))
+        if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "remove the registration to remove it");
         if ([...this.entries.values()].some((e) => e.parentId === id))
             throw entryErrors.hasChildren(collection, id);
@@ -587,7 +587,7 @@ export class MemoryEntryStore {
         this.refs.remove({ sourceKind: "entry", sourceId: id });
     }
     async reorder(collection, orderedIds) {
-        if (isSharedSchema(this.schema(collection)))
+        if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no order");
         orderedIds.forEach((id, i) => {
             const entry = this.row(collection, id);

package/dist/fields.d.ts

@@ -1,5 +1,6 @@
 import { type Toolset } from "./toolset.ts";
 import { type ResolvedFile, type ResolvedImage, type ResolvedVideo } from "./media.ts";
+import { type Condition, when } from "./conditions.ts";
 export type Descriptor = {
     type: string;
     [key: string]: unknown;
@@ -43,7 +44,8 @@ export type FieldBuilder<Value = unknown, Flags extends BuilderFlags = {}> = {
      * - no call — hydrate the entry itself; its refs stay ids
      */
     resolve(...projection: (string | Record<string, unknown>)[]): FieldBuilder<Value, Flags>;
-    tab(tab: "content" | "styles" | "media" | "meta"): FieldBuilder<Value, Flags>;
+    /** Hide the field while the condition holds (spec 2026-09-14 §12): it leaves the form and validation skips it; the stored value is kept. */
+    hidden(condition: Condition): FieldBuilder<Value, Flags>;
     /** phantom, type-level only */
     readonly __value?: Value;
     readonly __flags?: Flags;
@@ -83,7 +85,8 @@ export declare const f: {
     richtext: (opts?: {
         toolset?: Toolset;
     }) => FieldBuilder<unknown, {}>;
-    dataAttributes: () => FieldBuilder<Record<string, string>, {}>;
+    /** A condition for `.hidden()`: `f.when("settings.mediaType").is("video")`. */
+    when: typeof when;
     boolean: () => FieldBuilder<boolean, {}>;
     /** One value from a list, shown as a dropdown. */
     select: <const O extends readonly OptionInput[]>(options: O) => FieldBuilder<OptionValue<O[number]>, {}>;

package/dist/fields.js

@@ -3,6 +3,7 @@
 // keyed by descriptor type. Chaining is immutable.
 import { DEFAULT_TOOLSET } from "./toolset.js";
 import { parseAspect } from "./media.js";
+import { when } from "./conditions.js";
 /** Normalizes a schema's option list to objects; refuses an empty list,
  *  since a choice with nothing to choose is a schema bug (spec 2026-09-10
  *  page fields §1). */
@@ -43,7 +44,7 @@ function builder(descriptor) {
                 return chain({ resolve: projection[0] });
             return chain({ resolve: Object.fromEntries(projection.map((k) => [k, true])) });
         },
-        tab: (tab) => chain({ tab }),
+        hidden: (condition) => chain({ hidden: condition }),
     };
 }
 export const describePath = (path) => (path === "" ? "the item" : `"${path}"`);
@@ -97,7 +98,8 @@ export const f = {
     video: () => builder({ type: "video" }),
     file: () => builder({ type: "file" }),
     richtext: (opts) => builder({ type: "richtext", toolset: opts?.toolset ?? DEFAULT_TOOLSET }),
-    dataAttributes: () => builder({ type: "dataAttributes" }),
+    /** A condition for `.hidden()`: `f.when("settings.mediaType").is("video")`. */
+    when,
     boolean: () => builder({ type: "boolean" }),
     /** One value from a list, shown as a dropdown. */
     select: (options) => builder({ type: "select", options: normalizeOptions(options) }),

package/dist/{shared-id.d.ts → global-id.d.ts}

@@ -1,3 +1,3 @@
 /** RFC 4122 §4.3 uuid v5: sha1(namespace bytes ‖ name bytes), version 5,
  *  variant 10xx, first 16 bytes of the digest. */
-export declare function sharedEntryId(space: string, name: string): Promise<string>;
+export declare function globalEntryId(space: string, name: string): Promise<string>;

package/dist/{shared-id.js → global-id.js}

@@ -1,8 +1,8 @@
-// The row id of a shared item (spec 2026-09-07 §10 "§3 row id"): uuid v5
+// The row id of a global item (spec 2026-09-07 §10 "§3 row id"): uuid v5
 // of (space id as the namespace, item name as the name). Deterministic in
 // both adapters, so a second concurrent materialization of the same item
 // hits the `entries` primary key instead of adding an unremovable
-// duplicate — `delete` refuses every shared row. The space is part of it
+// duplicate — `delete` refuses every global row. The space is part of it
 // because the primary key is `id` alone and, in the cloud, many spaces
 // share one table: a name-only id would make space B's footer collide
 // with space A's.
@@ -16,7 +16,7 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 /** The namespace's 16 raw bytes — RFC 4122 hashes the bytes, not the text. */
 function uuidBytes(uuid) {
     if (!UUID_RE.test(uuid))
-        throw new Error(`smoodly: "${uuid}" is not a uuid — a shared item's namespace is the space id.`);
+        throw new Error(`smoodly: "${uuid}" is not a uuid — a global item's namespace is the space id.`);
     const hex = uuid.replace(/-/g, "");
     const bytes = new Uint8Array(16);
     for (let i = 0; i < 16; i++)
@@ -25,7 +25,7 @@ function uuidBytes(uuid) {
 }
 /** RFC 4122 §4.3 uuid v5: sha1(namespace bytes ‖ name bytes), version 5,
  *  variant 10xx, first 16 bytes of the digest. */
-export async function sharedEntryId(space, name) {
+export async function globalEntryId(space, name) {
     const input = new Uint8Array([...uuidBytes(space), ...new TextEncoder().encode(name)]);
     const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-1", input));
     const bytes = digest.subarray(0, 16);

package/dist/global.d.ts

@@ -0,0 +1,57 @@
+import type { CollectionSchema } from "./collections.ts";
+import type { Descriptor } from "./fields.ts";
+import type { PairedComponent } from "./pairing.tsx";
+import type { BuilderMap, NamespaceValues, SectionSchema } from "./schema.ts";
+import type { StyleProps } from "./styles.ts";
+/** The reserved tree node type of a placement. */
+export declare 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). */
+export declare const SETTINGS_KEY = "$settings";
+export declare const STYLES_KEY = "$styles";
+export declare const CSS_KEY = "$css";
+/** The node id a layout-rendered visual item carries (spec 2026-09-13 §1):
+ *  `getGlobal` stamps it into the styles' `__smd`, the section wrapper emits it,
+ *  the canvas selects by it. A placement keeps its own tree node id
+ *  (`global-xxxxxxxx`, no colon). */
+export declare const GLOBAL_NODE_PREFIX = "global:";
+export declare const globalNodeId: (name: string) => string;
+/** The item a layout node id names, or null for any other id. */
+export declare function globalNameOf(id: string): string | null;
+export type GlobalSchema<V = Record<string, unknown>, N extends string = string> = CollectionSchema<any, N> & {
+    kind: "global";
+    /** The registered section a visual item renders through; absent = an object item. */
+    section?: string;
+    /** The section's settings descriptors (empty for an object item). */
+    settings: Record<string, Descriptor>;
+    sample?: Record<string, unknown>;
+    /** phantom: what getGlobal returns */
+    readonly __value?: V;
+};
+export type GlobalLink = {
+    item: string;
+    ref: string;
+};
+/** The placement a tree node is, or null for any other node. Accepts a
+ *  bare `{ type, fields }` shape or a full tree node — `id` (and any
+ *  other tree-node property) is ignored. */
+export declare function globalLink(node: {
+    id?: string;
+    type: string;
+    fields?: Record<string, unknown>;
+}): GlobalLink | null;
+type GlobalInput<N extends string = string> = {
+    name: N;
+    title: string;
+};
+export declare function globalItem<F extends BuilderMap, const N extends string = string>(input: GlobalInput<N> & {
+    fields: F;
+    section?: undefined;
+}): GlobalSchema<NamespaceValues<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>;
+    fields?: undefined;
+}): GlobalSchema<NamespaceValues<F> & {
+    settings: NamespaceValues<St>;
+    styles: StyleProps;
+}, N>;
+export {};

package/dist/global.js

@@ -0,0 +1,51 @@
+/** 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). */
+export const SETTINGS_KEY = "$settings";
+export const STYLES_KEY = "$styles";
+export const CSS_KEY = "$css";
+const RESERVED_KEYS = [SETTINGS_KEY, STYLES_KEY, CSS_KEY];
+/** The node id a layout-rendered visual item carries (spec 2026-09-13 §1):
+ *  `getGlobal` stamps it into the styles' `__smd`, the section wrapper emits it,
+ *  the canvas selects by it. A placement keeps its own tree node id
+ *  (`global-xxxxxxxx`, no colon). */
+export const GLOBAL_NODE_PREFIX = "global:";
+export const globalNodeId = (name) => `${GLOBAL_NODE_PREFIX}${name}`;
+/** The item a layout node id names, or null for any other id. */
+export function globalNameOf(id) {
+    return id.startsWith(GLOBAL_NODE_PREFIX) && id.length > GLOBAL_NODE_PREFIX.length ? id.slice(GLOBAL_NODE_PREFIX.length) : null;
+}
+/** The placement a tree node is, or null for any other node. Accepts a
+ *  bare `{ type, fields }` shape or a full tree node — `id` (and any
+ *  other tree-node property) is ignored. */
+export function globalLink(node) {
+    if (node.type !== GLOBAL_NODE_TYPE)
+        return null;
+    const { item, ref } = node.fields ?? {};
+    return typeof item === "string" && typeof ref === "string" ? { item, ref } : null;
+}
+/** `smoodly.global()`: named `globalItem` here so nothing shadows the `global` idiom. */
+export function globalItem(input) {
+    if (!input?.name)
+        throw new Error("smoodly: a global item requires a name.");
+    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
+        : 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)) {
+            throw new Error(`smoodly: global item "${input.name}" has a field named "${key}" — that key is reserved for a visual item's ${key === SETTINGS_KEY ? "settings" : key === STYLES_KEY ? "styles" : "css"}.`);
+        }
+    }
+    return {
+        kind: "global",
+        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 } : {}),
+    };
+}

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { toolset } from "./toolset.ts";
 import { Section } from "./section-wrapper.tsx";
 import { page } from "./render.tsx";
 import { entryPage } from "./entry-page.tsx";
-import { shared } from "./shared.ts";
+import { globalItem } from "./global.ts";
 import { marks } from "./marks.ts";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.tsx";
 export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageLink, PageViewProps } from "./render.tsx";
@@ -14,6 +14,11 @@ export type { PageSchema } from "./page.ts";
 export { fixedSlug } from "./page.ts";
 export type { EntryPageSchema, PairedEntryPage, EntryPageProps } from "./entry-page.tsx";
 export { f, normalizeOptions, optionsOf, optionValues } from "./fields.ts";
+export { when, evaluate, isHidden, assertConditions, splitConditionPath } from "./conditions.ts";
+export { DEFAULT_STYLE_VALUES, STYLE_KEYS, SPACING_NONE, resolveStyleValues, styleDescriptors, inlineStyles } from "./styles.ts";
+export type { StyleValues, StyleValuesInput, StyleProps, StyleKey } from "./styles.ts";
+export * from "./custom/index.ts";
+export type { Condition, ConditionOp, ConditionScope } from "./conditions.ts";
 export { defaultsOf, withDefaults } from "./field-defaults.ts";
 export { filterPageTree } from "./page-tree.ts";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.ts";
@@ -39,7 +44,7 @@ export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
 export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.ts";
-export { affectedTargets, pageTag, entryTag, sharedTag, pagesTreeTag, collectionTag } from "./revalidate.ts";
+export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve.ts";
@@ -56,21 +61,28 @@ export type { CollectionSchema, EntryOrder } from "./collections.ts";
 export { DEFAULT_TOOLSET, type Toolset, type ToolsetMark, type ToolsetNode } from "./toolset.ts";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.ts";
 export type { ZonePolicy } from "./zones.ts";
-export { SHARED_NODE_TYPE, STYLES_KEY, sharedLink } from "./shared.ts";
-export { sharedEntryId } from "./shared-id.ts";
+export { GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY, CSS_KEY, globalLink } from "./global.ts";
+export { SMD_KEY } from "./section-wrapper.tsx";
+export type { SmdInternal } from "./section-wrapper.tsx";
+export { CSS_MAX, cssProblem, safeCss, scopedCss } from "./css.ts";
+export { globalEntryId } from "./global-id.ts";
 export { DEFAULT_SPACE_ID } from "./sql-space.ts";
-export type { SharedSchema, SharedLink } from "./shared.ts";
+export type { GlobalSchema, GlobalLink } from "./global.ts";
 export declare const smoodly: {
     schema: {
         page: typeof import("./page.ts").pageSchema;
-        section<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}, M extends import("./schema.ts").BuilderMap = {}>(input: {
+        section<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}>(input: {
             name: string;
             title: string;
             icon?: string;
             description?: string;
             fields?: F | undefined;
-            styles?: S | undefined;
-            meta?: M | undefined;
+            settings?: S | undefined;
+            meta?: never;
+            styles?: false | {
+                omit: string[];
+            };
+            css?: false;
             sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
                 __flags?: infer Fl;
             } ? Fl extends {
@@ -88,18 +100,19 @@ export declare const smoodly: {
             } ? Fl extends {
                 optional: true;
             } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
-            styleDefaults?: false | {
-                omit: string[];
-            };
         }): import("./schema.ts").SectionSchema<F, S>;
-        element<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}, M extends import("./schema.ts").BuilderMap = {}>(input: {
+        element<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}>(input: {
             name: string;
             title: string;
             icon?: string;
             description?: string;
             fields?: F | undefined;
-            styles?: S | undefined;
-            meta?: M | undefined;
+            settings?: S | undefined;
+            meta?: never;
+            styles?: false | {
+                omit: string[];
+            };
+            css?: false;
             sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
                 __flags?: infer Fl;
             } ? Fl extends {
@@ -117,9 +130,6 @@ export declare const smoodly: {
             } ? Fl extends {
                 optional: true;
             } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
-            styleDefaults?: false | {
-                omit: string[];
-            };
         } & {
             contexts: ("richtext" | "column")[];
         }): import("./schema.ts").ElementSchema<F, S>;
@@ -130,7 +140,7 @@ export declare const smoodly: {
     entryPage: typeof entryPage;
     collection: typeof collection;
     toolset: typeof toolset;
-    shared: typeof shared;
+    global: typeof globalItem;
     Section: typeof Section;
     marks: typeof marks;
 };

package/dist/index.js

@@ -5,12 +5,15 @@ import { toolset } from "./toolset.js";
 import { Section } from "./section-wrapper.js";
 import { page } from "./render.js";
 import { entryPage } from "./entry-page.js";
-import { shared } from "./shared.js";
+import { globalItem } from "./global.js";
 import { marks } from "./marks.js";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.js";
 export { RichText, defaultRichTextImage } from "./richtext-render.js";
 export { fixedSlug } from "./page.js";
 export { f, normalizeOptions, optionsOf, optionValues } from "./fields.js";
+export { when, evaluate, isHidden, assertConditions, splitConditionPath } from "./conditions.js";
+export { DEFAULT_STYLE_VALUES, STYLE_KEYS, SPACING_NONE, resolveStyleValues, styleDescriptors, inlineStyles } from "./styles.js";
+export * from "./custom/index.js";
 export { defaultsOf, withDefaults } from "./field-defaults.js";
 export { filterPageTree } from "./page-tree.js";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.js";
@@ -30,15 +33,17 @@ export { MemoryEntryStore } from "./entry-store.js";
 export { SupabaseEntryStore } from "./supabase-entry-store.js";
 export { SupabasePathIndex } from "./supabase-path-index.js";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.js";
-export { affectedTargets, pageTag, entryTag, sharedTag, pagesTreeTag, collectionTag } from "./revalidate.js";
+export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.js";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
 export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.js";
 export { fixedPathFor } from "./localize.js";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
 export { DEFAULT_TOOLSET } from "./toolset.js";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
-export { SHARED_NODE_TYPE, STYLES_KEY, sharedLink } from "./shared.js";
-export { sharedEntryId } from "./shared-id.js";
+export { GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY, CSS_KEY, globalLink } from "./global.js";
+export { SMD_KEY } from "./section-wrapper.js";
+export { CSS_MAX, cssProblem, safeCss, scopedCss } from "./css.js";
+export { globalEntryId } from "./global-id.js";
 export { DEFAULT_SPACE_ID } from "./sql-space.js";
 export const smoodly = {
     schema,
@@ -48,7 +53,7 @@ export const smoodly = {
     entryPage,
     collection,
     toolset,
-    shared,
+    global: globalItem,
     Section,
     marks,
 };

package/dist/media.js

@@ -43,7 +43,7 @@ export function collectAssetIds(values, descriptors, out, elements = {}) {
                 out.add(value.asset);
         }
         else if (d.type === "richtext") {
-            // Block nodes (spec 2026-09-08 block nodes §2): image nodes, and media inside a known element's fields and styles.
+            // Block nodes (spec 2026-09-08 block nodes §2): image nodes, and media inside a known element's fields and settings.
             for (const node of richtextBlocks(value)) {
                 if (node.type === IMAGE_NODE) {
                     const image = node.attrs.image;

package/dist/next/index.d.ts

@@ -2,4 +2,4 @@ export { createPageRenderer } from "./page-renderer.tsx";
 export type { PageRendererOptions, PathRenderOptions, PageRegistration } from "./page-renderer.tsx";
 export { metadataFrom } from "./meta.ts";
 export { createSmoodlyQueries } from "./queries.ts";
-export type { SmoodlyQueries, QueryOptions, EntriesQuery, TypedEntryItem, SharedValue } from "./queries.ts";
+export type { SmoodlyQueries, QueryOptions, EntriesQuery, TypedEntryItem, GlobalValue } from "./queries.ts";

package/dist/next/page-renderer.d.ts

@@ -2,7 +2,7 @@ import type { ComponentType, ReactElement } from "react";
 import type { Metadata } from "next";
 import type { Descriptor } from "../fields.ts";
 import { type PairedPage } from "../render.tsx";
-import type { SharedSchema } from "../shared.ts";
+import type { GlobalSchema } from "../global.ts";
 import { type SmoodlySite } from "../site.ts";
 /** A registered section, as renderPage's registry needs it. */
 type SectionEntry = ComponentType<any> & {
@@ -22,6 +22,8 @@ export type PageRegistration = ((props: any) => ReactElement) & {
 export type PageRendererOptions = {
     site: SmoodlySite;
     sections: SectionEntry[];
+    /** Registered Elements: what the custom section's default richtext renderer needs when no RichText is bound (spec 2026-09-14 §6). */
+    elements?: SectionEntry[];
     pages: ReadonlyArray<PageRegistration>;
     /** Locale-relative CMS path → site URL. Default: the path itself. With
      *  next-intl: `(path, locale) => getPathname({ locale, href: path })`. */
@@ -32,7 +34,7 @@ export type PathRenderOptions = {
     searchParams?: Promise<Record<string, string | string[] | undefined>>;
 };
 export declare function createPageRenderer(options: PageRendererOptions): {
-    getSmoodlyShared: <V>(item: SharedSchema<V>, opts?: {
+    getSmoodlyGlobal: <V>(item: GlobalSchema<V>, opts?: {
         locale?: string;
     }) => Promise<V | null>;
     renderSmoodlyPath: (segments: string[], opts?: PathRenderOptions) => Promise<ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>;

package/dist/next/page-renderer.js

@@ -7,7 +7,7 @@ import { EditorBridge } from "../admin/next/bridge.js";
 import { fixedPathFor } from "../localize.js";
 import { joinPath } from "../paths.js";
 import { renderPage } from "../render.js";
-import { entryTag, pageTag, sharedTag } from "../revalidate.js";
+import { entryTag, pageTag, globalTag } from "../revalidate.js";
 import { pageContextOf } from "../site.js";
 import { metadataFrom } from "./meta.js";
 export function createPageRenderer(options) {
@@ -35,7 +35,7 @@ export function createPageRenderer(options) {
                 notFound();
             }
             const page = pageContextOf(hit, (path) => href(path, locale));
-            return renderPage(Page, hit.tree, { sections: options.sections }, { editor, page });
+            return renderPage(Page, hit.tree, { sections: options.sections, elements: options.elements, styles: site.styles, custom: site.custom }, { editor, page });
         }
         const View = entryPages.get(hit.collection);
         if (!View) {
@@ -86,20 +86,20 @@ export function createPageRenderer(options) {
      *  error surfaces as a rejected promise like every other failure. */
     const fixedPath = (Page) => (locale) => fixedPathFor(Page.schema, locale, site.locales, site.homePageSlug);
     const literal = (segments) => () => joinPath(segments);
-    /** A shared item for a layout: cached per (item, locale) under the
-     *  shared tag outside draft mode, the live draft inside it. */
-    async function getSmoodlyShared(item, opts) {
+    /** A global item for a layout: cached per (item, locale) under the
+     *  global tag outside draft mode, the live draft inside it. */
+    async function getSmoodlyGlobal(item, opts) {
         await connection();
         const locale = opts?.locale ?? site.locales.default;
         const { isEnabled: draft } = await draftMode();
         if (draft)
-            return site.getShared(item, { locale, draft: true });
-        return unstable_cache(() => site.getShared(item, { locale }), ["smoodly-shared", item.name, locale], {
-            tags: [sharedTag(item.name)],
+            return site.getGlobal(item, { locale, draft: true });
+        return unstable_cache(() => site.getGlobal(item, { locale }), ["smoodly-global", item.name, locale], {
+            tags: [globalTag(item.name)],
         })();
     }
     return {
-        getSmoodlyShared,
+        getSmoodlyGlobal,
         renderSmoodlyPath: (segments, opts) => page(literal(segments), opts, any),
         smoodlyMetadata: (segments, opts) => metadata(literal(segments), opts, any),
         /** A fixed registration rendered from the developer's own route file. */

package/dist/next/queries.d.ts

@@ -1,6 +1,6 @@
 import type { CollectionSchema } from "../collections.ts";
 import type { EntryRecord } from "../entry-store.ts";
-import type { SharedSchema } from "../shared.ts";
+import type { GlobalSchema } from "../global.ts";
 import type { EntryQuery, PageTreeItem, SiteEntryItem, SitePage, SmoodlySite } from "../site.ts";
 export type QueryOptions = {
     locale?: string;
@@ -17,8 +17,8 @@ export type TypedEntryItem<C extends readonly CollectionSchema<any, string>[], N
         fields: EntryFields<C, N>;
     };
 };
-export type SharedValue<S extends readonly SharedSchema<any, string>[], N> = string extends S[number]["name"] ? Record<string, unknown> : NonNullable<ByName<S[number], N>["__value"]>;
-export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S extends readonly SharedSchema<any, string>[]> = {
+export type GlobalValue<S extends readonly GlobalSchema<any, string>[], N> = string extends S[number]["name"] ? Record<string, unknown> : NonNullable<ByName<S[number], N>["__value"]>;
+export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S extends readonly GlobalSchema<any, string>[]> = {
     /** The published page tree in a locale, every item with its page fields. */
     getPageTree(options?: QueryOptions): Promise<PageTreeItem[]>;
     /** A page by locale-relative path ("/company/about-us") or id. */
@@ -26,11 +26,11 @@ export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S
     /** Published entries of a collection: `where` (shared fields), `order`, `limit`, `parent` run in the store. */
     getEntries<N extends C[number]["name"]>(collection: N, options?: EntriesQuery): Promise<TypedEntryItem<C, N>[]>;
     getEntry<N extends C[number]["name"]>(collection: N, idOrPath: string, options?: QueryOptions): Promise<TypedEntryItem<C, N> | null>;
-    getShared<N extends S[number]["name"]>(item: N, options?: QueryOptions): Promise<SharedValue<S, N> | null>;
+    getGlobal<N extends S[number]["name"]>(item: N, options?: QueryOptions): Promise<GlobalValue<S, N> | null>;
 };
-export declare function createSmoodlyQueries<const C extends readonly CollectionSchema<any, string>[], const S extends readonly SharedSchema<any, string>[] = []>(options: {
+export declare function createSmoodlyQueries<const C extends readonly CollectionSchema<any, string>[], const S extends readonly GlobalSchema<any, string>[] = []>(options: {
     site: SmoodlySite;
     collections: C;
-    shared?: S;
+    globals?: S;
 }): SmoodlyQueries<C, S>;
 export {};