smoodly 0.0.16 → 0.0.18

package/dist/index.d.ts

@@ -4,16 +4,21 @@ 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";
+export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageContextAlternate, PageLink, PageViewProps } from "./render.tsx";
 export { RichText, defaultRichTextImage } from "./richtext-render.tsx";
 export type { RichTextProps, RichTextElement, RichTextImageProps } from "./richtext-render.tsx";
 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,12 +44,12 @@ 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";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.ts";
-export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions } from "./paths.ts";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
+export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions, LocaleAlternate, PageAlternate } from "./paths.ts";
 export { fixedPathFor } from "./localize.ts";
 export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.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 { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } 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) {
@@ -34,20 +34,24 @@ export function createPageRenderer(options) {
                 console.warn(`smoodly: no page registration named "${hit.template}" — the record at ${hit.path} is a 404.`);
                 notFound();
             }
-            const page = pageContextOf(hit, (path) => href(path, locale));
-            return renderPage(Page, hit.tree, { sections: options.sections }, { editor, page });
+            const page = pageContextOf(hit, href);
+            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) {
             console.warn(`smoodly: no entry page for collection "${hit.collection}" — the entry at ${hit.path} is a 404.`);
             notFound();
         }
-        return _jsx(View, { entry: hit.entry, path: hit.path });
+        return _jsx(View, { entry: hit.entry, path: hit.path, locale: hit.locale, locales: hit.locales });
     }
+    /** hreflang from the SAME map a language switch reads (spec 2026-09-15 §3): the locales with a URL, through href. */
     function alternates(hit) {
         if (site.locales.supported.length < 2)
             return {};
-        const languages = Object.fromEntries(Object.entries(hit.paths).map(([locale, path]) => [locale, href(path, locale)]));
+        const languages = {};
+        for (const [locale, alt] of Object.entries(hit.locales))
+            if (alt?.path)
+                languages[locale] = href(alt.path, locale);
         return { alternates: { languages } };
     }
     async function page(pathFor, opts, accept) {
@@ -86,20 +90,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 {};

package/dist/next/queries.js

@@ -1,12 +1,12 @@
 // The in-app read API (spec 2026-09-11): five typed queries over the
 // framework-free site layer, each draft-aware inside the editor preview
-// and cached under a tag outside it — the pattern getSmoodlyShared set.
+// and cached under a tag outside it — the pattern getSmoodlyGlobal set.
 // Lives in next/ because draftMode and unstable_cache are Next's; an
 // Astro glue wraps the same site reads over its own cache seam.
 import { unstable_cache } from "next/cache";
 import { draftMode } from "next/headers";
 import { connection } from "next/server";
-import { collectionTag, entryTag, pageTag, pagesTreeTag, sharedTag } from "../revalidate.js";
+import { collectionTag, entryTag, pageTag, pagesTreeTag, globalTag } from "../revalidate.js";
 /** JSON with object keys sorted at every level and `undefined` dropped, so two spellings of one query share a unit. */
 function stable(value) {
     if (Array.isArray(value))
@@ -26,7 +26,7 @@ function entriesKey(o) {
 }
 export function createSmoodlyQueries(options) {
     const { site } = options;
-    const sharedByName = new Map((options.shared ?? []).map((s) => [s.name, s]));
+    const globalByName = new Map((options.globals ?? []).map((s) => [s.name, s]));
     const localeOf = (o) => o?.locale ?? site.locales.default;
     /** Every query gates on the request (never a build prerender), then reads live in draft mode or cached under `tags`. */
     async function run(key, tags, read) {
@@ -76,12 +76,12 @@ export function createSmoodlyQueries(options) {
                 return hit;
             });
         },
-        async getShared(name, o) {
+        async getGlobal(name, o) {
             const locale = localeOf(o);
-            const item = sharedByName.get(name);
+            const item = globalByName.get(name);
             if (!item)
-                throw new Error(`smoodly: no shared item named "${name}".`);
-            return run(["shared", name, locale], [sharedTag(name)], (draft) => site.getShared(item, { locale, draft }));
+                throw new Error(`smoodly: no global item named "${name}".`);
+            return run(["global", name, locale], [globalTag(name)], (draft) => site.getGlobal(item, { locale, draft }));
         },
     };
 }

package/dist/page.js

@@ -30,12 +30,12 @@ function normalizePolicy(p) {
             return out;
         }
         case "freeform":
-            return { kind: "freeform", allow: p.allow, rows: p.rows };
+            return { kind: "freeform", allow: p.allow, custom: p.custom === true };
         case "locked":
             return {
                 kind: "locked",
                 component: p.component,
-                ...(typeof p.shared === "string" ? { shared: p.shared } : {}),
+                ...(typeof p.global === "string" ? { global: p.global } : {}),
             };
         default:
             throw new Error(`smoodly: unknown zone policy kind "${String(p.kind)}".`);

package/dist/pairing.d.ts

@@ -1,9 +1,11 @@
 import type { ComponentType, ReactElement } from "react";
 import type { BuilderMap, ElementSchema, NamespaceValues, SectionSchema } from "./schema.ts";
 import type { PageContext, ZoneContent } from "./render.tsx";
+import type { StyleProps } from "./styles.ts";
 /** What the view receives. A page view gets its zones and where it sits
- * in the tree; a section/element view gets field values flat and styles
- * complete (defaults filled). The page branch keys on `kind` — an
+ * in the tree; a section/element view gets field values flat, settings
+ * complete (defaults filled) and Smoodly's styles steps as stored (Default
+ * stores nothing — spec 2026-09-14 §2). The page branch keys on `kind` — an
  * optional-only check would match section schemas too, since a type
  * lacking `__zones` still extends `{ __zones?: X }`. */
 export type Props<S> = S extends {
@@ -17,19 +19,23 @@ export type Props<S> = S extends {
     __f?: infer F extends BuilderMap;
     __s?: infer St extends BuilderMap;
 } ? NamespaceValues<F> & {
-    styles: NamespaceValues<St>;
+    settings: NamespaceValues<St>;
+    styles: StyleProps;
 } : never;
-/** What hard-coded JSX may pass: fields flat, styles optional and partial. */
+/** What hard-coded JSX may pass: fields flat, settings optional and partial, styles optional. */
 type ExternalProps<F extends BuilderMap, St extends BuilderMap> = NamespaceValues<F> & {
-    styles?: Partial<NamespaceValues<St>>;
+    settings?: Partial<NamespaceValues<St>>;
+    styles?: StyleProps;
 };
 export type PairedComponent<Schema, F extends BuilderMap, St extends BuilderMap> = ((props: ExternalProps<F, St>) => ReactElement) & {
     schema: Schema;
 };
 export declare function section<F extends BuilderMap, St extends BuilderMap>(schema: SectionSchema<F, St>, View: ComponentType<NamespaceValues<F> & {
-    styles: NamespaceValues<St>;
+    settings: NamespaceValues<St>;
+    styles: StyleProps;
 }>): PairedComponent<SectionSchema<F, St>, F, St>;
 export declare function element<F extends BuilderMap, St extends BuilderMap>(schema: ElementSchema<F, St>, View: ComponentType<NamespaceValues<F> & {
-    styles: NamespaceValues<St>;
+    settings: NamespaceValues<St>;
+    styles: StyleProps;
 }>): PairedComponent<ElementSchema<F, St>, F, St>;
 export {};

package/dist/pairing.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { defaultsOf } from "./field-defaults.js";
 function pair(schema, View) {
-    const defaults = defaultsOf(schema.styles);
+    const defaults = defaultsOf(schema.settings);
     const Component = (props) => {
-        const { styles: styleOverrides, ...fields } = props ?? {};
-        const styles = { ...defaults, ...styleOverrides };
+        const { settings: overrides, styles, ...fields } = props ?? {};
+        const settings = { ...defaults, ...overrides };
         const V = View;
-        return _jsx(V, { ...fields, styles: styles });
+        return _jsx(V, { ...fields, settings: settings, styles: styles ?? {} });
     };
     Component.schema = schema;
     return Component;

package/dist/paths.d.ts

@@ -91,6 +91,27 @@ export declare function entrySegment(entry: EntryLike, locale: string): string |
 export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
     path?: string | Record<string, string>;
 }, set: LocaleSet): PathRow[];
+/** A target's address in one locale (spec 2026-09-15 §1). A page always
+ *  has both; an entry's slug is null when its row claims no URL, and its
+ *  path null then or when the collection has no `path`. */
+export type LocaleAlternate = {
+    slug: string | null;
+    path: string | null;
+};
+export type PageAlternate = {
+    slug: string;
+    path: string;
+};
+/** The page's address in EVERY supported locale, in config order: null
+ *  where the node is absent, where an ancestor is, or where `advertised`
+ *  says no — the site passes "published, or draft mode", so an
+ *  unpublished translation is never linked on the public site. */
+export declare function pageAlternates(node: PageLike, byId: (id: string) => PageLike | undefined, opts: PagePathOptions, advertised: (locale: string) => boolean): Record<string, PageAlternate | null>;
+/** The entry's address in EVERY supported locale, in config order: null
+ *  where the row is absent or not advertised. `pathIn` is the caller's
+ *  path source — the derived rows in a list, the `paths` index for one
+ *  loaded record — so both entry reads apply ONE rule. */
+export declare function entryAlternates(entry: EntryLike, set: LocaleSet, advertised: (locale: string) => boolean, pathIn: (locale: string) => string | null): Record<string, LocaleAlternate | null>;
 export type PageTreeNode<T extends PageLike> = {
     record: T;
     path: string | null;

package/dist/paths.js

@@ -130,6 +130,31 @@ export function entryPathRows(targets, byId, collection, set) {
     }
     return rows;
 }
+/** The page's address in EVERY supported locale, in config order: null
+ *  where the node is absent, where an ancestor is, or where `advertised`
+ *  says no — the site passes "published, or draft mode", so an
+ *  unpublished translation is never linked on the public site. */
+export function pageAlternates(node, byId, opts, advertised) {
+    const out = {};
+    for (const locale of opts.locales.supported) {
+        const own = node.locales[locale];
+        const path = own && advertised(locale) ? pagePathIn(node, byId, locale, opts) : null;
+        out[locale] = own && path !== null ? { slug: own.slug, path } : null;
+    }
+    return out;
+}
+/** The entry's address in EVERY supported locale, in config order: null
+ *  where the row is absent or not advertised. `pathIn` is the caller's
+ *  path source — the derived rows in a list, the `paths` index for one
+ *  loaded record — so both entry reads apply ONE rule. */
+export function entryAlternates(entry, set, advertised, pathIn) {
+    const out = {};
+    for (const locale of set.supported) {
+        const own = entry.locales[locale];
+        out[locale] = own && advertised(locale) ? { slug: own.slug, path: pathIn(locale) } : null;
+    }
+    return out;
+}
 export function buildPageTree(records, locale, opts) {
     const byId = (id) => records.find((r) => r.id === id);
     const build = (parentId) => records

package/dist/refs.d.ts

@@ -11,12 +11,12 @@ export declare function collectEntryRefs(fields: Record<string, unknown>, schema
 export type SectionLike = {
     name: string;
     fields: Record<string, Descriptor>;
-    styles?: Record<string, Descriptor>;
+    settings?: Record<string, Descriptor>;
 } | {
     schema: {
         name: string;
         fields: Record<string, Descriptor>;
-        styles?: Record<string, Descriptor>;
+        settings?: Record<string, Descriptor>;
     };
 };
 export declare function collectTreeRefs(tree: PageTree, sections: SectionLike[], elements?: SectionLike[]): RefEdge[];

package/dist/refs.js

@@ -4,7 +4,7 @@
 // and never the source of truth. Stores rewrite a source's edges on
 // every save; `refs` answers only the REVERSE question (who depends on
 // this?) — forward resolution stays resolveTree's job.
-import { sharedLink } from "./shared.js";
+import { globalLink } from "./global.js";
 import { ASSET_COLLECTION, isMediaValue, MEDIA_TYPES } from "./media.js";
 import { ELEMENT_NODE, IMAGE_NODE, elementOf, elementSchemas, elementSets, richtextBlocks } from "./richtext-walk.js";
 function targetOf(d) {
@@ -87,7 +87,7 @@ export function collectTreeRefs(tree, sections, elements) {
         for (const node of nodes) {
             // A placement (spec 2026-09-07 §5): one edge, keyed by the node id
             // so two placements of one item on one page stay distinct rows.
-            const link = sharedLink(node);
+            const link = globalLink(node);
             if (link) {
                 out.push({ field: node.id, targetCollection: link.item, targetId: link.ref });
                 continue;
@@ -96,8 +96,8 @@ export function collectTreeRefs(tree, sections, elements) {
             if (!schema)
                 continue; // fail-soft, same as renderPage
             collectFrom(node.fields, schema.fields, out, els);
-            if (schema.styles && node.styles)
-                collectFrom(node.styles, schema.styles, out, els);
+            if (schema.settings && node.settings)
+                collectFrom(node.settings, schema.settings, out, els);
         }
     }
     return out;

package/dist/render.d.ts

@@ -1,12 +1,19 @@
 import type { ComponentType, ReactElement } from "react";
+import type { PageAlternate } from "./paths.ts";
 import type { PageSchema } from "./page.ts";
 import type { BuilderMap, NamespaceValues } from "./schema.ts";
+import { type StyleValues } from "./styles.ts";
+import { type CustomOptions } from "./custom/index.ts";
 export type TreeNode = {
     id: string;
     type: string;
     fields: Record<string, unknown>;
+    /** The developer's knobs (spec 2026-09-14 §3). */
+    settings?: Record<string, unknown>;
+    /** Smoodly's styles steps (spec 2026-09-14 §2); absent keys are Default. */
     styles?: Record<string, unknown>;
-    meta?: Record<string, unknown>;
+    /** The custom-CSS snippet (spec 2026-09-14 §4), scoped by the wrapper. */
+    css?: string;
 };
 /** `meta` is the page's own metadata (SEO title, description, og image).
  * It rides inside the tree deliberately: trees are already JSONB in
@@ -35,16 +42,25 @@ export type PageLink = {
 export type PageContextLink = PageLink & {
     url: string;
 };
+/** The page's address in one other locale, `url` through the app's href seam (spec 2026-09-15 §3). */
+export type PageContextAlternate = PageAlternate & {
+    url: string;
+};
 export type PageContext<Fields = Record<string, unknown>> = {
     id: string;
     title: string;
     path: string;
     url: string;
+    /** The locale the page was rendered in. */
+    locale: string;
     /** The page's own fields, typed from its schema on the view; resolved, defaults applied. */
     fields: Fields;
     /** Root first, parent last. */
     ancestors: ReadonlyArray<PageContextLink>;
     children: ReadonlyArray<PageContextLink>;
+    /** One key per supported locale: the page's `{ slug, path, url }` there, or null where it is
+     *  absent or unpublished (draft mode: absent only). What a language switch links to. */
+    locales: Readonly<Record<string, PageContextAlternate | null>>;
 };
 /** The `page` prop of a view rendered outside the site (a test, a preview
  *  of a shape): a real object, so a view never guards an optional prop, but
@@ -60,6 +76,8 @@ export type ZoneContent = {
     readonly name: string;
     readonly nodes: TreeNode[];
     readonly components: ReadonlyMap<string, AnyPaired>;
+    /** The config's CSS values behind the styles set (spec 2026-09-14 §2). */
+    readonly styleValues: StyleValues;
     readonly editor: boolean;
 };
 export declare function Zone({ of: content }: {
@@ -76,6 +94,10 @@ export declare function page<Zones extends Record<string, unknown>, F extends Bu
 export type Registry = {
     sections?: AnyPaired[];
     elements?: AnyPaired[];
+    /** Resolved styles values; the package fallbacks when absent. */
+    styles?: StyleValues;
+    /** The custom section's bound RichText and breakpoint (spec 2026-09-14 §6); the defaults when absent. */
+    custom?: CustomOptions;
 };
 export declare function renderPage<Zones extends Record<string, unknown>>(Page: PairedPage<Zones>, tree: PageTree, registry: Registry, options?: {
     editor?: boolean;