smoodly 0.0.16 → 0.0.18

package/dist/conditions.d.ts

@@ -0,0 +1,33 @@
+import type { Descriptor } from "./fields.ts";
+export type ConditionOp = "is" | "isNot" | "in" | "isEmpty" | "isNotEmpty";
+export type Condition = {
+    path: string;
+    op: ConditionOp;
+    value?: unknown;
+};
+export declare function when(path: string): {
+    is: (value: unknown) => Condition;
+    isNot: (value: unknown) => Condition;
+    in: (values: readonly unknown[]) => Condition;
+    isEmpty: () => Condition;
+    isNotEmpty: () => Condition;
+};
+/** Where a condition reads: the current level's values, and the two namespaces. */
+export type ConditionScope = {
+    self: Record<string, unknown> | undefined;
+    fields?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+};
+/** `["settings", "mediaType"]` for a prefixed path, `[null, "kind"]` for a bare one. */
+export declare function splitConditionPath(path: string): [("fields" | "settings") | null, string];
+export declare function evaluate(c: Condition, scope: ConditionScope): boolean;
+/** True when the descriptor's condition holds; false without one. */
+export declare function isHidden(d: object, scope: ConditionScope): boolean;
+/** Every condition in both namespaces names a field that exists: a typo
+ *  fails at registration, not in the form. Walks objects (siblings are the
+ *  object's keys) and lists (an object item's keys; a scalar item reads the
+ *  list's own level). */
+export declare function assertConditions(owner: string, maps: {
+    fields: Record<string, Descriptor>;
+    settings: Record<string, Descriptor>;
+}): void;

package/dist/conditions.js

@@ -0,0 +1,79 @@
+export function when(path) {
+    if (typeof path !== "string" || path === "")
+        throw new Error("smoodly: f.when() needs a field path.");
+    return {
+        is: (value) => ({ path, op: "is", value }),
+        isNot: (value) => ({ path, op: "isNot", value }),
+        in: (values) => ({ path, op: "in", value: [...values] }),
+        isEmpty: () => ({ path, op: "isEmpty" }),
+        isNotEmpty: () => ({ path, op: "isNotEmpty" }),
+    };
+}
+const PREFIXES = ["fields", "settings"];
+/** `["settings", "mediaType"]` for a prefixed path, `[null, "kind"]` for a bare one. */
+export function splitConditionPath(path) {
+    for (const p of PREFIXES)
+        if (path.startsWith(`${p}.`))
+            return [p, path.slice(p.length + 1)];
+    return [null, path];
+}
+function lookup(path, scope) {
+    const [ns, key] = splitConditionPath(path);
+    const holder = ns === null ? scope.self : scope[ns];
+    return holder?.[key];
+}
+/** Empty as the validator sees it, plus a media value with no asset. */
+const isEmptyValue = (v) => v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0) ||
+    (typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0) ||
+    (typeof v === "object" && !Array.isArray(v) && "asset" in v && typeof v.asset !== "string");
+export function evaluate(c, scope) {
+    const v = lookup(c.path, scope);
+    switch (c.op) {
+        case "is": return v === c.value;
+        case "isNot": return v !== c.value;
+        case "in": return Array.isArray(c.value) && c.value.includes(v);
+        case "isEmpty": return isEmptyValue(v);
+        case "isNotEmpty": return !isEmptyValue(v);
+        default: return false;
+    }
+}
+const isCondition = (c) => typeof c === "object" && c !== null && typeof c.path === "string" && typeof c.op === "string";
+/** True when the descriptor's condition holds; false without one. */
+export function isHidden(d, scope) {
+    const { hidden } = d;
+    return isCondition(hidden) ? evaluate(hidden, scope) : false;
+}
+/** Every condition in both namespaces names a field that exists: a typo
+ *  fails at registration, not in the form. Walks objects (siblings are the
+ *  object's keys) and lists (an object item's keys; a scalar item reads the
+ *  list's own level). */
+export function assertConditions(owner, maps) {
+    const top = { fields: new Set(Object.keys(maps.fields)), settings: new Set(Object.keys(maps.settings)) };
+    const check = (key, d, siblings) => {
+        if (d.hidden === undefined)
+            return;
+        if (!isCondition(d.hidden))
+            throw new Error(`smoodly: ${owner}: "${key}" has a malformed hidden condition — use f.when(path).`);
+        const [ns, name] = splitConditionPath(d.hidden.path);
+        const known = ns === null ? siblings : top[ns];
+        if (!known.has(name))
+            throw new Error(`smoodly: ${owner}: "${key}" is hidden by "${d.hidden.path}", which is not a field.`);
+    };
+    const walk = (map) => {
+        const siblings = new Set(Object.keys(map));
+        for (const [key, d] of Object.entries(map)) {
+            check(key, d, siblings);
+            if (d.type === "object")
+                walk(d.fields);
+            if (d.type === "list") {
+                const item = d.item;
+                if (item.type === "object")
+                    walk(item.fields);
+                else
+                    check(key, item, siblings);
+            }
+        }
+    };
+    walk(maps.fields);
+    walk(maps.settings);
+}

package/dist/config.d.ts

@@ -1,6 +1,8 @@
-import type { Descriptor, FieldBuilder } from "./fields.ts";
+import type { Descriptor } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
-import type { SharedSchema } from "./shared.ts";
+import type { GlobalSchema } from "./global.ts";
+import { type StyleValues, type StyleValuesInput } from "./styles.ts";
+import { type CustomConfigInput, type ResolvedCustom } from "./custom/index.ts";
 type Registered = {
     schema: {
         kind: string;
@@ -8,10 +10,12 @@ type Registered = {
         slug?: string | Record<string, string>;
         collection?: string;
         fields?: Record<string, Descriptor>;
-        styles?: Record<string, Descriptor>;
-        styleDefaults?: false | {
+        settings?: Record<string, Descriptor>;
+        /** The section's toggles on Smoodly's styles set and the CSS box (spec 2026-09-14 §2, §4). */
+        styles?: false | {
             omit: string[];
         };
+        css?: false;
     };
 };
 export type SmoodlyConfig = {
@@ -21,8 +25,8 @@ export type SmoodlyConfig = {
         collections?: CollectionSchema<any>[];
         /** Page shapes and entry pages alike — everything that renders a URL. */
         pages?: Registered[];
-        /** Shared content: code-declared singletons (spec 2026-09-07). */
-        shared?: SharedSchema[];
+        /** Global content: code-declared singletons (spec 2026-09-07). */
+        globals?: GlobalSchema[];
     };
     locales: {
         default: string;
@@ -34,20 +38,17 @@ export type SmoodlyConfig = {
             depth: number;
         };
     };
-    styles?: {
-        sections?: Record<string, FieldBuilder<any, any>>;
-        elements?: Record<string, FieldBuilder<any, any>>;
-    };
-    rows?: {
-        splits: string[];
-    };
+    /** The CSS behind Smoodly's styles set (spec 2026-09-14 §2): a value per
+     *  spacing and width step, merged over the package fallbacks. */
+    styles?: StyleValuesInput;
+    /** The custom-CSS box (spec 2026-09-14 §4): off unless true. */
+    css?: boolean;
+    /** The custom section (spec 2026-09-14 §6): the columns' toolset, the stacking breakpoint, the project's bound RichText. */
+    custom?: CustomConfigInput;
     /** Slug of the page record the site root serves. The admin maps this
      * slug to "/" (canvas URL, Pages list) and every other slug to
      * "/<slug>"; the route file serving "/" must declare the same slug. */
     homePageSlug?: string;
-    meta?: {
-        dataAttributes?: boolean;
-    };
     database?: {
         provider: string;
     };
@@ -57,18 +58,24 @@ export type SmoodlyConfig = {
         accept?: string[];
     };
 };
-export type ResolvedConfig = SmoodlyConfig & {
+export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom"> & {
     homePageSlug: string;
     /** How deep editors may nest pages in the tree. Default 1 (flat). */
     pageDepth: number;
-    /** The section's styles with the config standard set merged in (section keys win). */
+    /** The styles set's CSS values, resolved over the fallbacks. */
+    styles: StyleValues;
+    /** Whether the custom-CSS box exists. */
+    css: boolean;
+    /** The custom section's resolved options. */
+    custom: ResolvedCustom;
+    /** Smoodly's styles set as descriptors for a section, after its `styles` toggle: `{}` for `false`. */
     resolvedStyles(sectionName: string): Record<string, Descriptor>;
     media: {
         maxSize: number;
         accept: string[];
     };
 };
-/** `shared`: the placement node type and an admin route; `asset`: the refs
+/** `global`: the placement node type and an admin route; `asset`: the refs
  *  target of every media edge; `media`: the admin's Media screen route. */
 export declare const RESERVED_NAMES: readonly string[];
 export declare function defineConfig(config: SmoodlyConfig): ResolvedConfig;

package/dist/config.js

@@ -1,8 +1,10 @@
 import { assertSegment, fixedPageSegments, perLocaleSegments } from "./paths.js";
 import { DEFAULT_MEDIA } from "./media.js";
-/** `shared`: the placement node type and an admin route; `asset`: the refs
+import { resolveStyleValues, styleDescriptors } from "./styles.js";
+import { resolveCustom } from "./custom/index.js";
+/** `global`: the placement node type and an admin route; `asset`: the refs
  *  target of every media edge; `media`: the admin's Media screen route. */
-export const RESERVED_NAMES = ["shared", "asset", "media"];
+export const RESERVED_NAMES = ["global", "asset", "media"];
 const isReserved = (name) => RESERVED_NAMES.includes(name);
 function assertUniqueNames(config) {
     const seen = new Set();
@@ -21,32 +23,32 @@ function assertUniqueNames(config) {
             throw new Error(`smoodly: duplicate registered name "${name}".`);
         seen.add(name);
     }
-    // Shared items get their own pass, after every other kind is settled: a
-    // shared item's name must be unique among shared items, and must not
+    // Global items get their own pass, after every other kind is settled: a
+    // global item's name must be unique among global items, and must not
     // collide with any collection/element/page/section name above — EXCEPT a
     // visual item may reuse the name of the registered section it renders
     // (spec 2026-09-07 §2's example pairs a "footer" section with a "footer"
     // item). That exemption is narrow: it only excuses a match against the
     // item's own, actually-registered section — never against a collection,
     // element, or page that happens to share the string, and never against a
-    // second shared item of the same name.
-    const sharedSeen = new Set();
-    for (const item of config.registry.shared ?? []) {
+    // second global item of the same name.
+    const globalSeen = new Set();
+    for (const item of config.registry.globals ?? []) {
         const ownSection = item.name === item.section && sectionNames.has(item.name);
         if (isReserved(item.name))
             throw new Error(`smoodly: "${item.name}" is a reserved name.`);
-        if (sharedSeen.has(item.name) || (seen.has(item.name) && !ownSection)) {
+        if (globalSeen.has(item.name) || (seen.has(item.name) && !ownSection)) {
             throw new Error(`smoodly: duplicate registered name "${item.name}".`);
         }
-        sharedSeen.add(item.name);
+        globalSeen.add(item.name);
     }
 }
 /** A visual item renders through a registered section. */
-function assertSharedSections(config) {
+function assertGlobalSections(config) {
     const sections = new Set((config.registry.sections ?? []).map((s) => s.schema.name));
-    for (const item of config.registry.shared ?? []) {
+    for (const item of config.registry.globals ?? []) {
         if (item.section !== undefined && !sections.has(item.section)) {
-            throw new Error(`smoodly: shared item "${item.name}" renders section "${item.section}", which is not registered.`);
+            throw new Error(`smoodly: global item "${item.name}" renders section "${item.section}", which is not registered.`);
         }
     }
 }
@@ -153,8 +155,10 @@ function assertToolsetElements(config) {
         toolsetElementNames(e.schema.fields, wanted);
     for (const c of config.registry.collections ?? [])
         toolsetElementNames(c.fields, wanted);
-    for (const s of config.registry.shared ?? [])
+    for (const s of config.registry.globals ?? [])
         toolsetElementNames(s.fields, wanted);
+    for (const n of config.custom?.toolset?.elements ?? [])
+        wanted.add(n);
     for (const name of wanted) {
         if (!registered.has(name))
             throw new Error(`smoodly: a toolset embeds element "${name}", which is not in registry.elements.`);
@@ -163,7 +167,7 @@ function assertToolsetElements(config) {
 export function defineConfig(config) {
     assertLocales(config);
     assertUniqueNames(config);
-    assertSharedSections(config);
+    assertGlobalSections(config);
     assertToolsetElements(config);
     assertRootSegments(config);
     const depth = config.pages?.tree?.depth ?? 1;
@@ -181,7 +185,8 @@ export function defineConfig(config) {
             throw new Error(`smoodly: homePageSlug "${homePageSlug}" is also the path of collection "${c.name}".`);
         }
     }
-    const standard = Object.fromEntries(Object.entries(config.styles?.sections ?? {}).map(([k, b]) => [k, b.descriptor]));
+    const styles = resolveStyleValues(config.styles);
+    const custom = resolveCustom(config.custom);
     const byName = new Map((config.registry.sections ?? []).map((s) => [s.schema.name, s.schema]));
     const media = {
         maxSize: config.media?.maxSize ?? DEFAULT_MEDIA.maxSize,
@@ -195,20 +200,16 @@ export function defineConfig(config) {
         homePageSlug,
         pageDepth: depth,
         media,
+        styles,
+        css: config.css === true,
+        custom,
         resolvedStyles(sectionName) {
             const schema = byName.get(sectionName);
             if (!schema)
                 throw new Error(`smoodly: unknown section "${sectionName}".`);
-            const own = schema.styles ?? {};
-            if (schema.styleDefaults === false)
-                return { ...own };
-            const omitted = new Set(schema.styleDefaults ? schema.styleDefaults.omit : []);
-            const merged = {};
-            for (const [k, d] of Object.entries(standard)) {
-                if (!omitted.has(k))
-                    merged[k] = d;
-            }
-            return { ...merged, ...own };
+            if (schema.styles === false)
+                return {};
+            return styleDescriptors(styles, schema.styles ? schema.styles.omit : []);
         },
     };
 }

package/dist/css.d.ts

@@ -0,0 +1,7 @@
+export declare const CSS_MAX = 4000;
+/** The first refusal, or null for a snippet the wrapper will render. */
+export declare function cssProblem(css: string): string | null;
+/** The snippet when it is a clean string, else "". */
+export declare function safeCss(css: unknown): string;
+/** Nested under the node's selector — every rule inside reaches the section only. */
+export declare function scopedCss(nodeId: string, css: string): string;

package/dist/css.js

@@ -0,0 +1,57 @@
+// The custom-CSS box (spec 2026-09-14 §4): a per-section snippet the
+// wrapper nests under the section's own [data-smd-node] selector. CSS
+// can do two things beyond styling — pull a remote stylesheet and beacon
+// to a host — so those, the two legacy code hooks and the tag-closing
+// sequence are refused at save and stripped at render, in that order.
+// The checks run on the snippet with its CSS escapes decoded, so
+// `\75 rl(` cannot spell `url(` past them; and the braces must balance,
+// so a `}` cannot step out of the node's selector block.
+export const CSS_MAX = 4000;
+const REFUSED = [
+    [/@import/i, "@import is not allowed."],
+    [/url\s*\(/i, "url() is not allowed."],
+    [/expression\s*\(/i, "expression() is not allowed."],
+    [/behavior\s*:/i, "behavior: is not allowed."],
+    [/<\//, '"</" is not allowed.'],
+];
+/** The snippet as the CSS tokenizer reads it: `\HHHHHH ` and `\c` escapes replaced by their characters. */
+function unescapeCss(css) {
+    return css
+        .replace(/\\([0-9a-fA-F]{1,6})[ \t\n\r\f]?/g, (_, hex) => {
+        const code = parseInt(hex, 16);
+        return code === 0 || code > 0x10ffff ? "\ufffd" : String.fromCodePoint(code);
+    })
+        .replace(/\\(.)/gs, "$1");
+}
+/** Every `{` closed by its own `}`, never a `}` first — the snippet stays inside the node's block. */
+function bracesBalance(css) {
+    let depth = 0;
+    for (const ch of css) {
+        if (ch === "{")
+            depth++;
+        else if (ch === "}" && --depth < 0)
+            return false;
+    }
+    return depth === 0;
+}
+/** The first refusal, or null for a snippet the wrapper will render. */
+export function cssProblem(css) {
+    if (css.length > CSS_MAX)
+        return `At most ${CSS_MAX} characters.`;
+    const decoded = unescapeCss(css);
+    for (const [re, message] of REFUSED)
+        if (re.test(css) || re.test(decoded))
+            return message;
+    if (!bracesBalance(css))
+        return "Braces must balance.";
+    return null;
+}
+/** The snippet when it is a clean string, else "". */
+export function safeCss(css) {
+    return typeof css === "string" && css !== "" && cssProblem(css) === null ? css : "";
+}
+/** Nested under the node's selector — every rule inside reaches the section only. */
+export function scopedCss(nodeId, css) {
+    const id = nodeId.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `[data-smd-node="${id}"]{${css}}`;
+}

package/dist/custom/CustomSection.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentType, ReactElement } from "react";
+import { SMD_KEY, type SmdInternal } from "../section-wrapper.tsx";
+import type { StyleProps } from "../styles.ts";
+import { type RichTextElement } from "../richtext-render.tsx";
+export type CustomOptions = {
+    /** The project's bound RichText (elements and <SmoodlyImage>); absent, the root renderer over `elements`. */
+    RichText?: ComponentType<{
+        doc: unknown;
+    }>;
+    breakpoint?: string;
+};
+export type CustomSectionProps = {
+    rows?: unknown;
+    settings?: Record<string, unknown>;
+    styles: StyleProps & {
+        [SMD_KEY]?: SmdInternal;
+    };
+};
+export type CustomSectionComponent = ((props: CustomSectionProps) => ReactElement) & {
+    schema: {
+        name: string;
+    };
+};
+export declare function createCustomSection({ RichText: Bound, breakpoint, elements }: CustomOptions & {
+    elements?: RichTextElement[];
+}): CustomSectionComponent;

package/dist/custom/CustomSection.js

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

package/dist/custom/css.d.ts

@@ -0,0 +1,3 @@
+import { type CustomRow } from "./schema.ts";
+export declare const isCssLength: (s: string) => boolean;
+export declare function customCss(nodeId: string, rows: CustomRow[], breakpoint: string): string;

package/dist/custom/css.js

@@ -0,0 +1,28 @@
+// The custom section's layout CSS (spec 2026-09-14 §6): emitted by
+// Smoodly, scoped under the node like the custom-CSS box, computed from
+// the stored NUMBERS and whitelisted keywords only — no editor string
+// reaches it. One rule per row by data-row (nth-child would count the
+// <style> children), one breakpoint that stacks every row.
+import { ALIGN_VALUES, GAP_VALUES, SPAN_TOTAL } from "./schema.js";
+import { renormalize } from "./rows.js";
+const LENGTH_RE = /^\d+(?:\.\d+)?(?:px|rem|em)$/;
+export const isCssLength = (s) => LENGTH_RE.test(s);
+const escapeId = (id) => id.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+export function customCss(nodeId, rows, breakpoint) {
+    const s = `[data-smd-node="${escapeId(nodeId)}"]`;
+    let css = `${s} .smd-row{display:grid;max-width:var(--smd-width,var(--container,none));margin-inline:auto;padding-inline:var(--smd-gutter,1rem);box-sizing:border-box}` +
+        `${s} .smd-row+.smd-row{margin-top:2rem}`;
+    rows.forEach((row, i) => {
+        const n = Array.isArray(row.columns) && row.columns.length > 0 ? row.columns.length : 1;
+        const spans = Array.isArray(row.spans) && row.spans.length === n && row.spans.every((x) => Number.isInteger(x) && x >= 1) && row.spans.reduce((a, b) => a + b, 0) === SPAN_TOTAL
+            ? row.spans
+            : renormalize(Array(n).fill(1));
+        const gap = GAP_VALUES[row.gap] ?? GAP_VALUES.md;
+        const align = ALIGN_VALUES[row.align] ?? ALIGN_VALUES.top;
+        css += `${s} [data-row="${i}"]{grid-template-columns:${spans.map((x) => `${x}fr`).join(" ")};gap:${gap};align-items:${align}}`;
+    });
+    // The reverse stack is a column flex box, whose cross axis is HORIZONTAL: the row's own align-items (Top → start)
+    // would shrink an image-only column to zero width, so the stack resets it (last in the sheet, equal specificity, wins).
+    css += `@media (max-width:${breakpoint}){${s} .smd-row{grid-template-columns:1fr}${s} .smd-row--reverse{display:flex;flex-direction:column-reverse;align-items:stretch}}`;
+    return css;
+}

package/dist/custom/index.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentType } from "react";
+import type { Toolset } from "../toolset.ts";
+import { customSchema } from "./schema.ts";
+export * from "./schema.ts";
+export * from "./rows.ts";
+export * from "./css.ts";
+export { createCustomSection } from "./CustomSection.tsx";
+export type { CustomOptions, CustomSectionProps, CustomSectionComponent } from "./CustomSection.tsx";
+/** `config.custom` / `site.custom` as written (spec 2026-09-14 §6). */
+export type CustomConfigInput = {
+    breakpoint?: string;
+    toolset?: Toolset;
+    RichText?: ComponentType<{
+        doc: unknown;
+    }>;
+};
+export type ResolvedCustom = {
+    breakpoint: string;
+    toolset: Toolset;
+    RichText?: ComponentType<{
+        doc: unknown;
+    }>;
+};
+/** Every section map the walks build gets the custom schema too (spec 2026-09-14 §6), so a column's images resolve and count as usage. */
+export declare function withCustomSchema<T>(sections: readonly T[], toolset: Toolset): (T | ReturnType<typeof customSchema>)[];
+export declare function resolveCustom(input?: CustomConfigInput): ResolvedCustom;

package/dist/custom/index.js

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

package/dist/custom/rows.d.ts

@@ -0,0 +1,28 @@
+import { type CustomRow } from "./schema.ts";
+export declare const EMPTY_DOC: {
+    type: string;
+    content: {
+        type: string;
+    }[];
+};
+export declare function defaultRow(columns?: number): CustomRow;
+/** Integers ≥ 1 summing to 12, proportions kept: scale, floor, hand the
+ *  remainder out by largest fraction (ties to the earlier column), then
+ *  lift any 0 to 1 from the largest column. */
+export declare function renormalize(spans: number[]): number[];
+export declare function setColumnCount(row: CustomRow, count: number): CustomRow;
+/** The boundary between columns `handle` and `handle + 1` moved so the left side is `left` twelfths; both sides keep ≥ 1. */
+export declare function setSpan(spans: number[], handle: number, left: number): number[];
+/** The left span a pointer at `x` over a bar `width` px wide asks for, for the handle between `handle` and `handle + 1`. */
+export declare function spanAtX(x: number, width: number, spans: number[], handle: number): number;
+export declare function presetsFor(n: number): {
+    label: string;
+    spans: number[];
+}[];
+export declare function concatDocs(a: unknown, b: unknown): unknown;
+/** The structural problems the publish validator reports, by dotted path. */
+export declare function rowsProblems(rows: unknown): {
+    field: string;
+    message: string;
+}[];
+export declare function columnsLabel(rows: unknown): string;