smoodly 0.0.16 → 0.0.18

package/dist/site.js

@@ -1,26 +1,33 @@
 import { ARRAY_FIELD_TYPES, entryFieldsIn, localizedKeys, schemaOf } from "./entry-store.js";
-import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
+import { buildPageTree, chainOf, entryAlternates, entryPathRows, entrySegment, pageAlternates, pagePath, } from "./paths.js";
 import { resolveFields, resolveMedia, resolveMediaSets, resolveTree } from "./resolve.js";
 import { elementSchemas } from "./richtext-walk.js";
-import { sharedNodeId, STYLES_KEY } from "./shared.js";
+import { globalNodeId, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
+import { SMD_KEY } from "./section-wrapper.js";
+import { resolveStyleValues } from "./styles.js";
+import { resolveCustom } from "./custom/index.js";
 import { withDefaults } from "./field-defaults.js";
-/** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
- *  bound to the render locale; the default keeps CMS paths as URLs. */
-export function pageContextOf(hit, toUrl = (p) => p) {
-    const withUrl = (l) => ({ ...l, url: toUrl(l.path) });
+/** The `page` prop for a loaded page. `href` is the app's seam from a
+ *  locale-relative path to a site URL; the default keeps CMS paths as URLs. */
+export function pageContextOf(hit, href = (p) => p) {
+    const withUrl = (l) => ({ ...l, url: href(l.path, hit.locale) });
     return {
         id: hit.record.id,
         title: hit.title,
         path: hit.path,
-        url: toUrl(hit.path),
+        url: href(hit.path, hit.locale),
+        locale: hit.locale,
         fields: hit.fields,
         ancestors: hit.ancestors.map(withUrl),
         children: hit.children.map(withUrl),
+        locales: Object.fromEntries(Object.entries(hit.locales).map(([code, alt]) => [code, alt && { ...alt, url: href(alt.path, code) }])),
     };
 }
 export function createSmoodlySite(options) {
     const locales = options.locales;
     const homePageSlug = options.homePageSlug ?? "home";
+    const styles = resolveStyleValues(options.styles);
+    const custom = resolveCustom(options.custom);
     const elements = elementSchemas(options.elements);
     const pathOpts = { locales, homePageSlug };
     const mounted = options.collections.filter((c) => c.path !== undefined);
@@ -33,9 +40,9 @@ export function createSmoodlySite(options) {
         const assets = options.stores().assets;
         return assets ? (ids) => assets.getMany(ids) : undefined;
     };
-    const sectionStyles = (name) => {
+    const sectionSettings = (name) => {
         const s = options.sections.find((x) => ("schema" in x ? x.schema : x).name === name);
-        return (s && ("schema" in s ? s.schema : s).styles) ?? {};
+        return (s && ("schema" in s ? s.schema : s).settings) ?? {};
     };
     /** Visible to the public in a locale: present there, and a folder or a
      *  published page. Draft mode sees every present node. Presence is the
@@ -108,11 +115,12 @@ export function createSmoodlySite(options) {
         const tree = await resolveTree(raw, {
             sections: options.sections,
             collections: options.collections,
-            shared: options.shared,
+            globals: options.globals,
             elements: options.elements,
             fetch: fetcher(draft, locale),
             assets: assetFetcher(),
             page: { fields: pageFields(record.template) },
+            custom,
         });
         const all = await pages.listPages();
         const index = new Map(all.map((n) => [n.id, n]));
@@ -122,10 +130,12 @@ export function createSmoodlySite(options) {
         const fields = await linkFields([...chain.slice(0, -1), ...kids], locale, draft);
         const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft, fields));
         const children = kids.map((n) => link(n, byId, locale, draft, fields));
-        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
-        const paths = Object.fromEntries(Object.entries(await pages.pathsOf(id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
+        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present
+        // one. Derived from the tree already listed — no index lookup (spec 2026-09-15 §2).
+        const alternates = pageAlternates(record, byId, pathOpts, (l) => draft || record.locales[l]?.status === "published");
         return {
             kind: "page",
+            locale,
             record,
             template: record.template,
             tree,
@@ -134,7 +144,7 @@ export function createSmoodlySite(options) {
             fields: withDefaults(tree.fields, pageFields(record.template)),
             ancestors,
             children,
-            paths,
+            locales: alternates,
         };
     }
     async function loadEntry(id, locale, path, draft) {
@@ -156,8 +166,11 @@ export function createSmoodlySite(options) {
                 return null;
             const fields = await resolveFields(raw, schema.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), assets: assetFetcher() });
             // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
-            const paths = Object.fromEntries(Object.entries(await entries.pathsOf(schema.name, id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
-            return { kind: "entry", collection: schema.name, entry: { ...record, fields }, path, paths };
+            // One record is in memory (a nested entry's parents are not), so the `paths` index
+            // supplies the paths — the same single lookup as before (spec 2026-09-15 §2).
+            const known = await entries.pathsOf(schema.name, id);
+            const alternates = entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", (l) => known[l] ?? null);
+            return { kind: "entry", locale, collection: schema.name, entry: { ...record, fields }, path, locales: alternates };
         }
         return null;
     }
@@ -165,15 +178,21 @@ export function createSmoodlySite(options) {
     /** One locale's published fields and path for entries of one collection;
      *  `all` is the whole collection (a draft ancestor still contributes
      *  its segment). `fieldsById` is the published read for the locale. */
-    function entryItems(schema, wanted, all, locale, fieldsById) {
+    function entryItems(schema, wanted, all, locale, draft, fieldsById) {
         const index = new Map(all.map((e) => [e.id, e]));
         const byId = (x) => index.get(x);
         return wanted
             .filter((record) => fieldsById[record.id] !== undefined)
-            .map((record) => ({
-            entry: { ...record, fields: fieldsById[record.id] },
-            path: entryPathRows([record], byId, schema, locales).find((r) => r.locale === locale)?.path ?? null,
-        }));
+            .map((record) => {
+            const rows = entryPathRows([record], byId, schema, locales);
+            const pathIn = (l) => rows.find((r) => r.locale === l)?.path ?? null;
+            return {
+                entry: { ...record, fields: fieldsById[record.id] },
+                path: pathIn(locale),
+                locale,
+                locales: entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", pathIn),
+            };
+        });
     }
     async function getEntries(collection, o = {}) {
         const schema = schemaOf(options.collections, collection);
@@ -214,7 +233,7 @@ export function createSmoodlySite(options) {
         const fetchAssets = assetFetcher();
         if (fetchAssets)
             await resolveMediaSets(Object.values(fieldsById).map((values) => ({ values, descriptors: schema.fields })), fetchAssets, elements);
-        return entryItems(schema, inLocale, all, locale, fieldsById);
+        return entryItems(schema, inLocale, all, locale, draft, fieldsById);
     }
     const api = {
         async getPagesTree(o) {
@@ -251,7 +270,7 @@ export function createSmoodlySite(options) {
             const locale = localeOf(o);
             if (idOrPath.startsWith("/")) {
                 const hit = await site.resolve(locale, idOrPath, { draft: o?.draft ?? false });
-                return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path } : null;
+                return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path, locale: hit.locale, locales: hit.locales } : null;
             }
             const items = await getEntries(collection, { locale, draft: o?.draft ?? false });
             const byId = items.find((i) => i.entry.id === idOrPath);
@@ -267,7 +286,7 @@ export function createSmoodlySite(options) {
             const build = (parentId) => items.filter((i) => i.entry.parentId === parentId).map((i) => ({ ...i, children: build(i.entry.id) }));
             return build(null);
         },
-        async getShared(item, o) {
+        async getGlobal(item, o) {
             const locale = localeOf(o);
             const draft = o?.draft ?? false;
             const { entries } = options.stores();
@@ -285,18 +304,26 @@ export function createSmoodlySite(options) {
             const fields = await resolveFields(raw, item.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), assets: assetFetcher() });
             if (!item.section)
                 return fields;
-            const { [STYLES_KEY]: styles, ...rest } = fields;
+            const { [SETTINGS_KEY]: settings, [STYLES_KEY]: steps, [CSS_KEY]: css, ...rest } = fields;
             const fetch = assetFetcher();
-            const own = styles !== null && typeof styles === "object" ? styles : {};
+            const own = settings !== null && typeof settings === "object" ? settings : {};
             if (fetch)
-                await resolveMedia(own, sectionStyles(item.section), fetch, elements);
-            // The layout node id rides the styles: the wrapper strips it and emits data-smd-node (spec 2026-09-13 §1).
-            return { ...rest, styles: { ...own, __smoodlyNode: sharedNodeId(item.name) } };
+                await resolveMedia(own, sectionSettings(item.section), fetch, elements);
+            // The layout node id, the css and the values ride the styles under the reserved key (spec 2026-09-13 §1, 2026-09-14 §2, §4):
+            // the wrapper strips it and emits data-smd-node, so the canvas selects the item and the css reaches it.
+            const stepsObject = steps !== null && typeof steps === "object" ? steps : {};
+            return {
+                ...rest,
+                settings: own,
+                styles: { ...stepsObject, [SMD_KEY]: { node: globalNodeId(item.name), css: typeof css === "string" ? css : undefined, values: styles } },
+            };
         },
     };
     const site = {
         locales,
         homePageSlug,
+        styles,
+        custom,
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
         load(target, locale, path, opts = {}) {
             const draft = opts.draft ?? false;

package/dist/sql-space.js

@@ -31,7 +31,7 @@ $$;`.trim();
 }
 /** Which rows a read key (or the anon key, which has no claim) may see.
  *  null = write keys only — refs is editor tooling; editors is admission
- *  data; nothing a browser needs. Shared content (spec 2026-09-07) rides
+ *  data; nothing a browser needs. Global content (spec 2026-09-07) rides
  *  the three entry predicates: it is stored as entries. */
 const PUBLISHED_READ = {
     pages: `exists (select 1 from "page_locales" l where l."page_id" = "pages"."id" and l."status" = 'published')`,

package/dist/sql.js

@@ -31,7 +31,7 @@ function fieldExpr(key, d, source) {
         case "date":
             return `(${source}->>'${key}')::timestamptz`;
         default:
-            return `${source}->'${key}'`; // image, video, file, object, list, richtext, dataAttributes, refList
+            return `${source}->'${key}'`; // image, video, file, object, list, richtext, refList
     }
 }
 export function collectionSQL(collection) {
@@ -179,7 +179,7 @@ create index if not exists "entry_locales_status_idx"
 -- A version belongs to ONE locale of one entry and stores the MERGED
 -- fields (shared + localized + slug) as they were at that save, so
 -- restoring an old Finnish version restores the shared fields too.
--- Rows for every collection and every shared item (spec 2026-09-14 §1).
+-- Rows for every collection and every global item (spec 2026-09-14 §1).
 -- One row per publish plus the live draft (spec 2026-09-13 history §1).
 create table if not exists "entry_versions" (
   "id" uuid primary key default gen_random_uuid(),

package/dist/store.d.ts

@@ -1,6 +1,7 @@
 import type { PageTree } from "./render.tsx";
 import type { EntryStore } from "./entry-store.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
+import type { Toolset } from "./toolset.ts";
 import type { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
 import { type LocaleSet, type PagePathOptions, type PathTarget } from "./paths.ts";
@@ -107,6 +108,10 @@ export type PageStoreOptions = {
     sections?: SectionLike[];
     /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
     elements?: SectionLike[];
+    /** The custom section's columns toolset (spec 2026-09-14 §6); with `sections` given, the custom schema always joins the ref walk. */
+    custom?: {
+        toolset?: Toolset;
+    };
     entries?: EntryStore;
     /** The shared URL index (one instance for pages AND entries). */
     paths?: PathIndex;
@@ -117,6 +122,8 @@ export type PageStoreOptions = {
     };
 };
 export declare const DEFAULT_LOCALES: LocaleSet;
+/** The section list every adapter walks refs with: the registered ones plus the custom section's schema (spec 2026-09-14 §6). */
+export declare function refSections(options: PageStoreOptions): SectionLike[] | undefined;
 /** The options every adapter resolves the same way. */
 export declare function pathOptions(options: PageStoreOptions): PagePathOptions & {
     depth: number;

package/dist/store.js

@@ -11,9 +11,14 @@
 // locale — presence IS the row.
 import { ASSET_COLLECTION } from "./media.js";
 import { collectTreeRefs } from "./refs.js";
+import { customToolset, withCustomSchema } from "./custom/index.js";
 import { MemoryPathIndex } from "./path-index.js";
 import { assertDepth, assertSegment, assertSupportedLocale, chainOf, isHomeNode, pagePathRows, unsupportedLocale, } from "./paths.js";
 export const DEFAULT_LOCALES = { default: "en", supported: ["en"] };
+/** The section list every adapter walks refs with: the registered ones plus the custom section's schema (spec 2026-09-14 §6). */
+export function refSections(options) {
+    return options.sections ? withCustomSchema(options.sections, customToolset(options.custom?.toolset)) : undefined;
+}
 /** The options every adapter resolves the same way. */
 export function pathOptions(options) {
     return {
@@ -98,6 +103,7 @@ export class MemoryPageStore {
         /** Append-only creation-order tie-break; `size + 1` stays fresh only because entries are never deleted. */
         this.seq = new Map();
         this.byId = (id) => this.pages.get(id);
+        this.options = { ...options, sections: refSections(options) };
         this.paths = options.paths ?? new MemoryPathIndex();
         this.opts = pathOptions(options);
     }

package/dist/styles.d.ts

@@ -0,0 +1,27 @@
+import type { Descriptor } from "./fields.ts";
+export type StyleValues = {
+    spacing: Record<string, string>;
+    width: Record<string, string>;
+};
+export type StyleValuesInput = {
+    spacing?: Record<string, string>;
+    width?: Record<string, string>;
+};
+export declare const DEFAULT_STYLE_VALUES: StyleValues;
+/** The "0" step: always present, always `0`, never a config key. */
+export declare const SPACING_NONE = "none";
+export declare const ALIGN_STEPS: readonly ["left", "center", "right"];
+export declare const STYLE_KEYS: readonly ["spacingTop", "spacingBottom", "width", "align"];
+export type StyleKey = (typeof STYLE_KEYS)[number];
+/** What a view receives: steps, not CSS. A config may add steps, so the strings stay open. */
+export type StyleProps = {
+    spacingTop?: string;
+    spacingBottom?: string;
+    width?: string;
+    align?: (typeof ALIGN_STEPS)[number];
+};
+export declare function resolveStyleValues(input?: StyleValuesInput): StyleValues;
+/** The set as admin descriptors: optional radios (the empty pill is Default), product labels. */
+export declare function styleDescriptors(values: StyleValues, omit?: readonly string[]): Record<string, Descriptor>;
+/** The inline CSS for a node's steps. Unknown steps and non-strings render nothing. */
+export declare function inlineStyles(steps: Record<string, unknown> | undefined, values: StyleValues): Record<string, string | number>;

package/dist/styles.js

@@ -0,0 +1,60 @@
+export const DEFAULT_STYLE_VALUES = {
+    spacing: { sm: "1.5rem", md: "3.5rem", lg: "5.5rem" },
+    width: { narrow: "40rem", wide: "90rem", full: "none" },
+};
+/** The "0" step: always present, always `0`, never a config key. */
+export const SPACING_NONE = "none";
+export const ALIGN_STEPS = ["left", "center", "right"];
+export const STYLE_KEYS = ["spacingTop", "spacingBottom", "width", "align"];
+export function resolveStyleValues(input) {
+    const spacing = { ...DEFAULT_STYLE_VALUES.spacing, ...(input?.spacing ?? {}) };
+    if (SPACING_NONE in spacing)
+        throw new Error(`smoodly: styles.spacing cannot define "${SPACING_NONE}" — the 0 step is always 0.`);
+    const width = { ...DEFAULT_STYLE_VALUES.width, ...(input?.width ?? {}) };
+    for (const [group, map] of Object.entries({ spacing, width })) {
+        for (const [k, v] of Object.entries(map)) {
+            if (typeof v !== "string" || v === "")
+                throw new Error(`smoodly: styles.${group}.${k} must be a CSS value.`);
+        }
+    }
+    return { spacing, width };
+}
+const SPACING_LABELS = { [SPACING_NONE]: "0", sm: "S", md: "M", lg: "L" };
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const radio = (options) => ({ type: "radio", optional: true, options });
+/** The set as admin descriptors: optional radios (the empty pill is Default), product labels. */
+export function styleDescriptors(values, omit = []) {
+    const spacingOptions = () => [
+        { value: SPACING_NONE, label: "0" },
+        ...Object.keys(values.spacing).map((k) => ({ value: k, label: SPACING_LABELS[k] ?? k.toUpperCase() })),
+    ];
+    const all = {
+        spacingTop: radio(spacingOptions()),
+        spacingBottom: radio(spacingOptions()),
+        width: radio(Object.keys(values.width).map((k) => ({ value: k, label: capitalize(k) }))),
+        align: radio(ALIGN_STEPS.map((k) => ({ value: k, label: capitalize(k) }))),
+    };
+    const out = {};
+    for (const key of STYLE_KEYS)
+        if (!omit.includes(key))
+            out[key] = all[key];
+    return out;
+}
+/** The inline CSS for a node's steps. Unknown steps and non-strings render nothing. */
+export function inlineStyles(steps, values) {
+    const out = {};
+    if (!steps)
+        return out;
+    const spacing = (v) => v === SPACING_NONE ? 0 : typeof v === "string" && v in values.spacing ? values.spacing[v] : undefined;
+    const top = spacing(steps.spacingTop);
+    if (top !== undefined)
+        out.paddingTop = top;
+    const bottom = spacing(steps.spacingBottom);
+    if (bottom !== undefined)
+        out.paddingBottom = bottom;
+    if (typeof steps.width === "string" && steps.width in values.width)
+        out["--smd-width"] = values.width[steps.width];
+    if (typeof steps.align === "string" && ALIGN_STEPS.includes(steps.align))
+        out.textAlign = steps.align;
+    return out;
+}

package/dist/supabase-entry-store.js

@@ -7,8 +7,8 @@
 // calls the smoodly_reorder SQL function: one statement, updated_at
 // untouched.
 import { collectionDepth, collectionOrder } from "./collections.js";
-import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isSharedSchema, schemaOf, splitFields, } from "./entry-store.js";
-import { sharedEntryId } from "./shared-id.js";
+import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, schemaOf, splitFields, } from "./entry-store.js";
+import { globalEntryId } from "./global-id.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { assertDepth, assertSupportedLocale, entryPathRows, slugOf } from "./paths.js";
 // entries.id is a Postgres uuid column: filtering on a non-UUID string
@@ -48,7 +48,7 @@ export class SupabaseEntryStore {
         this.db = db;
         this.paths = options.paths ?? new SupabasePathIndex(db);
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
-        this.schemas = [...collections, ...(options.shared ?? [])];
+        this.schemas = [...collections, ...(options.globals ?? [])];
         this.elements = options.elements;
     }
     fail(message) {
@@ -293,7 +293,7 @@ export class SupabaseEntryStore {
         const schema = this.schema(collection);
         assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
-        if (isSharedSchema(schema)) {
+        if (isGlobalSchema(schema)) {
             const existing = await this.db.from("entries").select("id").eq("collection", collection).limit(1);
             if (existing.error)
                 this.fail(existing.error.message);
@@ -306,17 +306,17 @@ export class SupabaseEntryStore {
         this.assertParentHasLocale(parent, options.locale);
         const { shared, localized, slug } = splitFields(fields, schema);
         await this.assertSiblingSlug(collection, parentId, options.locale, slug);
-        // A shared item's row id is DERIVED from (space, name), not generated
+        // A global item's row id is DERIVED from (space, name), not generated
         // (spec 2026-09-07 §10): the SELECT above is a fast path two racing
         // materializations can both pass, so the primary key is the backstop
         // — a duplicate would be unremovable, since `delete` refuses every
-        // shared row.
+        // global row.
         const row = { collection, parent_id: parentId, fields: shared };
-        if (isSharedSchema(schema))
-            row.id = await sharedEntryId(await this.space(), collection);
+        if (isGlobalSchema(schema))
+            row.id = await globalEntryId(await this.space(), collection);
         const inserted = await this.db.from("entries").insert(row).select("id").single();
         if (inserted.error) {
-            if (isSharedSchema(schema) && inserted.error.code === UNIQUE_VIOLATION)
+            if (isGlobalSchema(schema) && inserted.error.code === UNIQUE_VIOLATION)
                 throw entryErrors.singleton(collection);
             this.fail(inserted.error.message);
         }
@@ -423,7 +423,7 @@ export class SupabaseEntryStore {
         const row = entryLocaleRow(before, locale);
         await this.ensureLiveSnapshot(before, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
-        if (isSharedSchema(schema) && slug !== null)
+        if (isGlobalSchema(schema) && slug !== null)
             throw entryErrors.noSlug(collection);
         await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
         await this.updateNode(id, { fields: shared });
@@ -511,7 +511,7 @@ export class SupabaseEntryStore {
     }
     async removeLocale(collection, id, locale) {
         const schema = this.schema(collection);
-        if (isSharedSchema(schema))
+        if (isGlobalSchema(schema))
             throw entryErrors.everyLocale(collection);
         const entry = await this.must(collection, id);
         entryLocaleRow(entry, locale);
@@ -575,7 +575,7 @@ export class SupabaseEntryStore {
         return res.data ? toVersion(res.data) : 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 = await this.must(collection, id);
         const subtree = await this.subtree(entry);
@@ -622,7 +622,7 @@ export class SupabaseEntryStore {
         const entry = await this.fetch(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");
         const children = await this.db.from("entries").select("id").eq("parent_id", id).limit(1);
         if (children.error)
@@ -649,7 +649,7 @@ export class SupabaseEntryStore {
         return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
     }
     async reorder(collection, orderedIds) {
-        if (isSharedSchema(this.schema(collection)))
+        if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no order");
         const res = await this.db.rpc("smoodly_reorder", { p_collection: collection, p_ids: orderedIds });
         if (res.error)

package/dist/supabase-store.js

@@ -6,7 +6,7 @@
 // are two indexed lookups. Every read embeds the locale rows
 // (`*, page_locales(*)`) so a record arrives whole. Path rows are
 // rewritten through ONE RPC per write, so a collision rolls back.
-import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, } from "./store.js";
+import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { assertDepth, assertSegment, isHomeNode, pagePathRows } from "./paths.js";
 const SELECT = "*, page_locales(*)";
@@ -40,6 +40,7 @@ export class SupabasePageStore {
     constructor(db, options = {}) {
         this.db = db;
         this.options = options;
+        this.options = { ...options, sections: refSections(options) };
         this.paths = options.paths ?? new SupabasePathIndex(db);
         this.opts = pathOptions(options);
     }

package/dist/zones.d.ts

@@ -1,4 +1,4 @@
-import type { SharedSchema } from "./shared.ts";
+import type { GlobalSchema } from "./global.ts";
 type WithSchema = {
     schema: {
         name: string;
@@ -8,16 +8,18 @@ export type ZonePolicy = {
     kind: "sections";
     allow: string[];
     max?: number;
-} | {
+}
+/** `custom`: whether editors may add a custom section here (spec 2026-09-14 §6). */
+ | {
     kind: "freeform";
     allow: string[] | "*";
-    rows: boolean;
+    custom: boolean;
 }
-/** `shared` names the item a bound zone shows (spec 2026-09-07 §4); `component` is its section either way. */
+/** `global` names the item a bound zone shows (spec 2026-09-07 §4); `component` is its section either way. */
  | {
     kind: "locked";
     component: string;
-    shared?: string;
+    global?: string;
 };
 export declare const z: {
     sections(components: WithSchema[]): {
@@ -28,8 +30,8 @@ export declare const z: {
     };
     freeform(opts: {
         sections: WithSchema[] | "*";
-        rows?: boolean;
+        custom?: boolean;
     }): ZonePolicy;
-    locked(target: WithSchema | SharedSchema): ZonePolicy;
+    locked(target: WithSchema | GlobalSchema): ZonePolicy;
 };
 export {};

package/dist/zones.js

@@ -1,6 +1,6 @@
 // Zone policies — the freedom dial. Policies reference paired components
 // directly; only their registered names are stored (plain data).
-const isShared = (target) => "kind" in target && target.kind === "shared";
+const isGlobal = (target) => "kind" in target && target.kind === "global";
 const names = (components) => components.map((c) => c.schema.name);
 export const z = {
     sections(components) {
@@ -15,14 +15,14 @@ export const z = {
         return {
             kind: "freeform",
             allow: opts.sections === "*" ? "*" : names(opts.sections),
-            rows: opts.rows ?? false,
+            custom: opts.custom ?? false,
         };
     },
     locked(target) {
-        if (isShared(target)) {
+        if (isGlobal(target)) {
             if (!target.section)
-                throw new Error(`smoodly: shared item "${target.name}" has no section — a locked zone needs a visual item.`);
-            return { kind: "locked", component: target.section, shared: target.name };
+                throw new Error(`smoodly: global item "${target.name}" has no section — a locked zone needs a visual item.`);
+            return { kind: "locked", component: target.section, global: target.name };
         }
         return { kind: "locked", component: target.schema.name };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {

package/dist/admin/editor/SharedInspector.d.ts

@@ -1,23 +0,0 @@
-import type { AdminShared } from "../serialize.ts";
-import type { TabEntry } from "../forms/tabs.ts";
-import type { SharedEditItem } from "./shared-edit.ts";
-import { type RefOption } from "../shell/SharedFields.tsx";
-import { type PublishBusy } from "../ui/PublishControl.tsx";
-export declare function SharedInspector({ item, edit, locale, entries, multilingual, refOptions, inlinePath, onEditHere, onChange, pending, busy, onPublish, onDiscard, onUnpublish, }: {
-    item: AdminShared;
-    /** null while the item loads. */
-    edit: SharedEditItem | null;
-    locale: string;
-    entries: TabEntry[];
-    multilingual: boolean;
-    refOptions: Record<string, RefOption[]>;
-    inlinePath?: string;
-    onEditHere?(): void;
-    onChange(ns: "fields" | "styles", key: string, value: unknown): void;
-    /** An edit the store has not confirmed (dirty, or the item's autosave not in `saved`). */
-    pending: boolean;
-    busy: PublishBusy;
-    onPublish(): void;
-    onDiscard(): void;
-    onUnpublish(): void;
-}): import("react").JSX.Element;

package/dist/admin/editor/SharedInspector.js

@@ -1,13 +0,0 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { BASE } from "../shell/base.js";
-import { localeStatusOf } from "../shell/pages-tree.js";
-import { SharedFields } from "../shell/SharedFields.js";
-import { PublishControl } from "../ui/PublishControl.js";
-export function SharedInspector({ item, edit, locale, entries, multilingual, refOptions, inlinePath, onEditHere, onChange, pending, busy, onPublish, onDiscard, onUnpublish, }) {
-    const row = edit?.record.locales[locale];
-    // The same three states the shared list shows; the control decides what applies.
-    const status = row ? localeStatusOf(row) : "draft";
-    const pages = edit ? [...new Set(edit.usage.filter((u) => u.sourceKind === "page").map((u) => u.sourceId))] : [];
-    return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [_jsx("p", { className: "sm-hint", children: "Shared content \u2014 changes every page it is used on." }), edit && (_jsxs("p", { className: "sm-hint", children: [pages.length === 0 ? "Not placed on any page." : `Used on ${pages.length} page${pages.length === 1 ? "" : "s"}: `, pages.map((id, i) => (_jsxs("span", { children: [i > 0 && ", ", _jsx("a", { href: `${BASE}/pages/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`, children: id })] }, id)))] })), _jsx("div", { style: { display: "flex", alignItems: "center", gap: 8, flexWrap: "wrap" }, children: _jsx(PublishControl, { status: row ? status : null, pending: pending, busy: busy, disabled: !edit, onPublish: onPublish, onDiscard: onDiscard, onUnpublish: onUnpublish }) }), edit ? (_jsx(SharedFields, { item: item, entries: entries, fields: edit.fields, errors: edit.errors, refOptions: refOptions, multilingual: multilingual, inlinePath: inlinePath, onEditHere: onEditHere, onChange: onChange })) : (_jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" }))] }));
-}

package/dist/admin/editor/useSharedEdit.d.ts

@@ -1,6 +0,0 @@
-import type { AdminOps } from "../ops.ts";
-import { type SharedEdit, type SharedEditState } from "./shared-edit.ts";
-export declare function useSharedEdit({ ops, onSaved }: {
-    ops: Pick<AdminOps, "shared">;
-    onSaved?: () => void;
-}): SharedEditState & Pick<SharedEdit, "load" | "patch" | "flush" | "setStatus" | "reset">;

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

@@ -1,9 +0,0 @@
-import type { ResolvedConfig } from "../config.ts";
-import type { Descriptor } from "../fields.ts";
-import type { EntryRecord, EntryStore } from "../entry-store.ts";
-import { type SharedSchema } from "../shared.ts";
-/** 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 declare function initialSharedFields(item: SharedSchema, resolvedStyles: Record<string, Descriptor>): Record<string, unknown>;
-export declare function ensureSharedItems(entries: EntryStore, config: ResolvedConfig): Promise<Record<string, EntryRecord>>;

package/dist/admin/shell/SharedFields.d.ts

@@ -1,21 +0,0 @@
-import type { AdminShared } from "../serialize.ts";
-import type { TabEntry } from "../forms/tabs.ts";
-export type RefOption = {
-    id: string;
-    title: string;
-    status: string;
-};
-export declare function SharedFields({ item, entries, fields, errors, refOptions, multilingual, inlinePath, onEditHere, onChange }: {
-    item: AdminShared;
-    entries: TabEntry[];
-    /** The merged draft fields; a visual item's styles under `$styles`. */
-    fields: Record<string, unknown>;
-    errors?: Record<string, string>;
-    /** Loaded ref options by target collection. */
-    refOptions: Record<string, RefOption[]>;
-    multilingual: boolean;
-    /** The content field with an active inline session: its richtext widget yields to a note. */
-    inlinePath?: string;
-    onEditHere?(): void;
-    onChange(ns: "fields" | "styles", key: string, value: unknown): void;
-}): import("react").JSX.Element;