@ciderpress/ui 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/node.mjs

@@ -4,13 +4,16 @@ import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveOptionalIcon, serializeIcon } from "@ciderpress/config";
 import { BRAND_COLORS, BUILT_IN_THEMES, DEFAULT_THEME_NAME, defineTheme, isBuiltInTheme, resolveDefaultVariant, resolveThemeAlias, resolveThemeVariants, themeToCss } from "@ciderpress/theme";
-import { match as match_match } from "massaman/match";
+import { P, match as match_match } from "massaman/match";
 import { visit as external_unist_util_visit_visit } from "unist-util-visit";
 import path_0 from "path";
 import { Project, SyntaxKind as external_ts_morph_SyntaxKind } from "ts-morph";
 import node_process from "node:process";
 import katex from "katex";
+import { unfold } from "massaman/array";
+import react from "react";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 import { createRequire as __rspack_createRequire } from "node:module";
@@ -8763,7 +8766,7 @@ const svgCaseSensitiveTagNames = [
     'textPath'
 ];
 const lib_h = createH(property_information_html, 'div');
-const s = createH(property_information_svg, 'g', svgCaseSensitiveTagNames);
+const lib_s = createH(property_information_svg, 'g', svgCaseSensitiveTagNames);
 function lib_location(file) {
     const value = String(file);
     const indices = [];
@@ -8915,7 +8918,7 @@ function lib_element(state, node) {
         const name = (attribute.prefix ? attribute.prefix + ':' : '') + attribute.name;
         if (!own.call(proto, name)) properties[name] = attribute.value;
     }
-    const x = 'svg' === state.schema.space ? s : lib_h;
+    const x = 'svg' === state.schema.space ? lib_s : lib_h;
     const result = x(node.tagName, properties, hast_util_from_parse5_lib_all(state, node.childNodes));
     patch(state, node, result);
     if ('template' === result.tagName) {
@@ -17285,8 +17288,14 @@ const APPLE_LOADER_CSS = readCss('css/loader-apple.css');
 const DOTS_LOADER_CSS = readCss('css/loader-dots.css');
 const DEFAULT_LOADER_STYLE = 'apple';
 function resolveLoaderCss(loader) {
+    if (false === loader) return '';
     if ('classic' === loader) return BACKDROP_CSS + DOTS_LOADER_CSS;
-    return BACKDROP_CSS + APPLE_LOADER_CSS;
+    if ('apple' === loader) return BACKDROP_CSS + APPLE_LOADER_CSS;
+    if (isStaticLoader(loader)) return BACKDROP_CSS + buildCustomLoaderCss(loader);
+    return BACKDROP_CSS;
+}
+function isStaticLoader(loader) {
+    return 'content' in loader && 'string' == typeof loader.content;
 }
 function getThemeCss(themeName, loader = DEFAULT_LOADER_STYLE) {
     const loaderCss = resolveLoaderCss(loader);
@@ -17296,14 +17305,78 @@ function getThemeCss(themeName, loader = DEFAULT_LOADER_STYLE) {
     if (themeColors) return themeColors + loaderCss;
     return loaderCss;
 }
+function buildCustomLoaderCss(config) {
+    const glyph = resolveGlyphUrl(config.content);
+    const label = config.label ?? 'loading';
+    const hasLabel = label.length > 0;
+    const labelRule = match_match(hasLabel).with(true, ()=>buildLabelCss(label)).otherwise(()=>'');
+    const marginLeft = match_match(hasLabel).with(true, ()=>'-110px').otherwise(()=>'-32px');
+    return `
+html::before {
+  content: '';
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  width: 64px;
+  height: 64px;
+  margin-left: ${marginLeft};
+  margin-top: -32px;
+  background-image: ${glyph};
+  background-repeat: no-repeat;
+  background-position: center center;
+  background-size: contain;
+  image-rendering: pixelated;
+  z-index: 9999;
+  pointer-events: none;
+  opacity: 1;
+  transition: opacity 0.2s ease;
+}
+${labelRule}
+html.cp-loader-fade::before,
+html.cp-loader-fade::after {
+  opacity: 0;
+}
+html[data-cp-ready]::before,
+html[data-cp-ready]::after {
+  display: none;
+}
+`;
+}
+function resolveGlyphUrl(content) {
+    if (content.includes('<svg')) return `url("data:image/svg+xml;utf8,${encodeURIComponent(content)}")`;
+    const safe = content.replaceAll('\\', String.raw`\\`).replaceAll('"', String.raw`\"`).replaceAll('<', String.raw`\3c `).replaceAll('\n', String.raw`\A `).replaceAll('\r', String.raw`\D `).replaceAll('\f', String.raw`\C `);
+    return `url("${safe}")`;
+}
+function buildLabelCss(label) {
+    const escaped = label.replaceAll('\\', String.raw`\\`).replaceAll("'", String.raw`\'`).replaceAll('<', String.raw`\3c `).replaceAll('\n', String.raw`\A `).replaceAll('\r', String.raw`\D `).replaceAll('\f', String.raw`\C `);
+    return `html::after {
+  content: '${escaped}';
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  width: 160px;
+  margin-left: -40px;
+  margin-top: -14px;
+  text-align: left;
+  color: var(--cp-c-text-2, #888);
+  font-family: var(--cp-ff-display, 'Geist Pixel Square', ui-sans-serif, system-ui, sans-serif);
+  font-size: 28px;
+  font-weight: 400;
+  line-height: 1;
+  letter-spacing: 0.04em;
+  z-index: 9999;
+  pointer-events: none;
+  opacity: 1;
+  transition: opacity 0.2s ease;
+}`;
+}
 function ciderpressPlugin() {
     const componentsDir = node_path.resolve(import.meta.dirname, 'theme', 'components');
     return {
         name: 'ciderpress',
         globalUIComponents: [
             node_path.resolve(componentsDir, 'theme-provider.tsx'),
-            node_path.resolve(componentsDir, 'edit-source-button.tsx'),
-            node_path.resolve(componentsDir, 'nav', 'nav-logo.tsx')
+            node_path.resolve(componentsDir, 'edit-source-button.tsx')
         ]
     };
 }
@@ -17379,6 +17452,410 @@ function mermaidPlugin(options = {}) {
         builderConfig: remarkMermaid.builderConfig
     };
 }
+const SAFE_PROTOCOLS = new Set([
+    'http:',
+    'https:',
+    'mailto:',
+    'tel:'
+]);
+const PROTOCOL_PATTERN = /^[a-z][a-z0-9+.-]*:/i;
+const FORBIDDEN_CHARS_PATTERN = /[\u0000-\u0020\u007F]/u;
+function safeUrl(href) {
+    const trimmed = href.trim();
+    if (FORBIDDEN_CHARS_PATTERN.test(trimmed)) return null;
+    return match_match(trimmed).with('', ()=>null).with(P.string.startsWith('#'), ()=>trimmed).with(P.string.startsWith('/'), ()=>trimmed).with(P.string.startsWith('./'), ()=>trimmed).with(P.string.startsWith('../'), ()=>trimmed).otherwise(()=>{
+        const match_ = trimmed.match(PROTOCOL_PATTERN);
+        if (!match_) return trimmed;
+        const scheme = match_[0].toLowerCase();
+        if (SAFE_PROTOCOLS.has(scheme)) return trimmed;
+        return null;
+    });
+}
+const ALLOWED_TAGS = new Set([
+    'b',
+    'strong',
+    'i',
+    'em',
+    'code',
+    'kbd',
+    'mark',
+    'sup',
+    'sub',
+    'span',
+    'small',
+    'u',
+    's',
+    'del',
+    'ins'
+]);
+const STRIPPED_TAGS = new Set([
+    "script",
+    'style',
+    'iframe',
+    'object',
+    'embed',
+    'template',
+    "noscript"
+]);
+const ACCENT_CLASS = 'cp-accent';
+const MARK_CLASS = 'cp-mark';
+const TOKEN_PATTERN = /(?:\\([*=`[\]<\\]))|(?:`([^`]+)`)|(?:\*\*([\s\S]+?)\*\*)|(?:==([\s\S]+?)==)|(?:(?<!\*)\*(?=[^\s*])([^*\n]+?)(?<=[^\s*])\*(?!\*))|(?:\[([^\]]*)\]\(((?:[^()\s]|\([^()\s]*\))+)\))|(?:<(\/?)\s*([a-zA-Z][a-zA-Z0-9-]*)(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*)>)/;
+const ATTR_PATTERN = /([a-zA-Z-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const CLOSE_TAG_BOUNDARY = /[\s>]/;
+function parseRichText(text) {
+    if ('string' != typeof text || 0 === text.length) return [];
+    return parseInline({
+        input: text,
+        inLink: false
+    });
+}
+function toPlainText(text) {
+    return flattenNodes(parseRichText(text));
+}
+function parseInline({ input, inLink }) {
+    return unfold((remaining)=>{
+        if (0 === remaining.length) return false;
+        const found = TOKEN_PATTERN.exec(remaining);
+        if (null === found) return [
+            [
+                {
+                    kind: 'text',
+                    value: remaining
+                }
+            ],
+            ''
+        ];
+        const lead = remaining.slice(0, found.index);
+        const after = remaining.slice(found.index + found[0].length);
+        const step = consumeToken({
+            found,
+            after,
+            inLink
+        });
+        return [
+            [
+                ...textNodes(lead),
+                ...step.nodes
+            ],
+            step.rest
+        ];
+    }, input).flat();
+}
+function textNodes(lead) {
+    if (0 === lead.length) return [];
+    return [
+        {
+            kind: 'text',
+            value: lead
+        }
+    ];
+}
+function consumeToken({ found, after, inLink }) {
+    const [, escaped, code, bold, highlight, italic, linkText, linkHref, closing, tagName, rawAttrs] = found;
+    if (void 0 !== escaped) return {
+        nodes: [
+            {
+                kind: 'text',
+                value: escaped
+            }
+        ],
+        rest: after
+    };
+    if (void 0 !== code) return {
+        nodes: [
+            codeNode(code)
+        ],
+        rest: after
+    };
+    if (void 0 !== bold) return {
+        nodes: [
+            accentNode(parseInline({
+                input: bold,
+                inLink
+            }))
+        ],
+        rest: after
+    };
+    if (void 0 !== highlight) return {
+        nodes: [
+            markNode(parseInline({
+                input: highlight,
+                inLink
+            }))
+        ],
+        rest: after
+    };
+    if (void 0 !== italic) return {
+        nodes: [
+            rich_text_parse_element({
+                tag: 'em',
+                children: parseInline({
+                    input: italic,
+                    inLink
+                })
+            })
+        ],
+        rest: after
+    };
+    if (void 0 !== linkHref) return {
+        nodes: linkNodes({
+            text: linkText ?? '',
+            href: linkHref,
+            inLink
+        }),
+        rest: after
+    };
+    if (void 0 !== tagName) {
+        const tail = (rawAttrs ?? '').trimEnd();
+        const isSelfClosing = tail.endsWith('/');
+        return consumeTag({
+            tagName: tagName.toLowerCase(),
+            attrs: match_match(isSelfClosing).with(true, ()=>tail.slice(0, -1)).otherwise(()=>tail),
+            isClosing: '/' === closing,
+            isSelfClosing,
+            after,
+            inLink
+        });
+    }
+    return {
+        nodes: [
+            {
+                kind: 'text',
+                value: found[0]
+            }
+        ],
+        rest: after
+    };
+}
+function consumeTag(params) {
+    const { tagName, attrs, isClosing, isSelfClosing, after, inLink } = params;
+    if (isClosing) return {
+        nodes: [],
+        rest: after
+    };
+    if ('br' === tagName) return {
+        nodes: [
+            {
+                kind: 'break'
+            }
+        ],
+        rest: after
+    };
+    if (isSelfClosing) return {
+        nodes: selfClosingNodes({
+            tagName,
+            attrs
+        }),
+        rest: after
+    };
+    const close = findClosingTag({
+        text: after,
+        tagName
+    });
+    if (null === close) {
+        if (STRIPPED_TAGS.has(tagName)) return {
+            nodes: [],
+            rest: ''
+        };
+        return {
+            nodes: [],
+            rest: after
+        };
+    }
+    const inner = after.slice(0, close.start);
+    const rest = after.slice(close.end);
+    if (STRIPPED_TAGS.has(tagName)) return {
+        nodes: [],
+        rest
+    };
+    if ('a' === tagName) return {
+        nodes: anchorNodes({
+            attrs,
+            inner,
+            inLink
+        }),
+        rest
+    };
+    if (ALLOWED_TAGS.has(tagName)) return {
+        nodes: [
+            taggedElement({
+                tag: tagName,
+                attrs,
+                children: parseInline({
+                    input: inner,
+                    inLink
+                })
+            })
+        ],
+        rest
+    };
+    return {
+        nodes: parseInline({
+            input: inner,
+            inLink
+        }),
+        rest
+    };
+}
+function selfClosingNodes({ tagName, attrs }) {
+    if (!ALLOWED_TAGS.has(tagName)) return [];
+    return [
+        taggedElement({
+            tag: tagName,
+            attrs,
+            children: []
+        })
+    ];
+}
+function findClosingTag({ text, tagName }) {
+    return scanForClose({
+        lower: text.toLowerCase(),
+        tagName,
+        from: 0
+    });
+}
+function scanForClose({ lower, tagName, from }) {
+    const needle = `</${tagName}`;
+    const candidates = unfold((offset)=>{
+        const at = lower.indexOf(needle, offset);
+        if (-1 === at) return false;
+        return [
+            at,
+            at + needle.length
+        ];
+    }, from);
+    const start = candidates.find((at)=>CLOSE_TAG_BOUNDARY.test(lower.charAt(at + needle.length)));
+    if (void 0 === start) return null;
+    const gt = lower.indexOf('>', start);
+    if (-1 === gt) return null;
+    return {
+        start,
+        end: gt + 1
+    };
+}
+function parseAttrs(attrs) {
+    const entries = [
+        ...attrs.matchAll(ATTR_PATTERN)
+    ];
+    return entries.reduce((acc, entry)=>{
+        const name = entry[1].toLowerCase();
+        const value = entry[2] ?? entry[3] ?? '';
+        return match_match(name).with('class', ()=>({
+                ...acc,
+                className: value
+            })).with('classname', ()=>({
+                ...acc,
+                className: value
+            })).with('title', ()=>({
+                ...acc,
+                title: value
+            })).with('href', ()=>({
+                ...acc,
+                href: value
+            })).otherwise(()=>acc);
+    }, {});
+}
+function taggedElement({ tag, attrs, children }) {
+    const parsed = parseAttrs(attrs);
+    return {
+        kind: 'element',
+        tag,
+        className: parsed.className,
+        title: parsed.title,
+        children
+    };
+}
+function anchorNodes({ attrs, inner, inLink }) {
+    const { href } = parseAttrs(attrs);
+    if (void 0 === href || inLink) return parseInline({
+        input: inner,
+        inLink
+    });
+    const safe = safeUrl(href);
+    if (null === safe) return parseInline({
+        input: inner,
+        inLink
+    });
+    const children = parseInline({
+        input: inner,
+        inLink: true
+    });
+    return linkOrChildren({
+        href: safe,
+        children
+    });
+}
+function linkNodes({ text, href, inLink }) {
+    const safe = safeUrl(href);
+    if (null === safe || inLink) return parseInline({
+        input: text,
+        inLink
+    });
+    return linkOrChildren({
+        href: safe,
+        children: parseInline({
+            input: text,
+            inLink: true
+        })
+    });
+}
+function linkOrChildren({ href, children }) {
+    if (0 === children.length) return [];
+    return [
+        {
+            kind: 'link',
+            href,
+            children
+        }
+    ];
+}
+function codeNode(value) {
+    return {
+        kind: 'code',
+        value
+    };
+}
+function accentNode(children) {
+    return {
+        kind: 'element',
+        tag: 'strong',
+        className: ACCENT_CLASS,
+        children
+    };
+}
+function markNode(children) {
+    return {
+        kind: 'element',
+        tag: 'mark',
+        className: MARK_CLASS,
+        children
+    };
+}
+function rich_text_parse_element({ tag, children }) {
+    return {
+        kind: 'element',
+        tag,
+        children
+    };
+}
+function flattenNodes(nodes) {
+    return nodes.map(flattenNode).join('');
+}
+function flattenNode(node) {
+    return match_match(node).with({
+        kind: 'text'
+    }, (n)=>n.value).with({
+        kind: 'code'
+    }, (n)=>n.value).with({
+        kind: 'break'
+    }, ()=>' ').with({
+        kind: 'link'
+    }, (n)=>flattenNodes(n.children)).with({
+        kind: 'element'
+    }, (n)=>flattenNodes(n.children)).exhaustive();
+}
+const DEFAULT_LOADER_MIN_MS = 150;
+const DEFAULT_LOADER_MAX_MS = 5000;
 const VSCODE_SET_JS = "document.documentElement.dataset.ciderpressEnv='vscode'";
 const VSCODE_NAV_JS = readJs('js/vscode-nav.js');
 const LOADER_DOTS_JS = readJs('js/loader-dots.js');
@@ -17395,7 +17872,22 @@ function createRspressConfig(options) {
         name: 'scopes.json',
         fallback: []
     });
+    const pageBadges = loadGenerated({
+        contentDir: paths.contentDir,
+        name: 'badges.json',
+        fallback: {}
+    });
     const gitBranch = detectGitBranch();
+    const brand = config.brand;
+    const home = config.home;
+    const editLink = config.editLink;
+    const reportLink = config.reportLink;
+    const topbar = config.topbar;
+    const sidebar = config.sidebar;
+    const footer = config.footer;
+    const favicon = brand && brand.favicon;
+    const loaderRaw = brand && brand.loader;
+    const logoRaw = brand && brand.logo;
     const themeName = resolveThemeName(config, options.themeOverride);
     const userThemes = resolveUserThemes(config);
     const variant = resolveActiveVariant({
@@ -17408,35 +17900,59 @@ function createRspressConfig(options) {
     const themeColors = resolveThemeColors(config);
     const themeDarkColors = resolveThemeDarkColors(config);
     const userThemesCss = userThemes.map(themeToCss).join('');
-    const loaderStyle = config.loader ?? 'apple';
+    const loaderStyle = resolveLoaderStyle(loaderRaw);
     const themeCss = getThemeCss(themeName, loaderStyle) + userThemesCss;
     const themeRegistry = [
         ...BUILT_IN_THEME_REGISTRY,
         ...userThemes.map(buildRegistryEntry)
     ];
     const isVscode = true === vscode;
+    const loaderMaxMs = resolveLoaderMaxMs(loaderRaw);
     const headScriptBody = buildHeadScriptBody({
         variant,
         themeName,
         vscode: isVscode,
-        registry: themeRegistry
+        registry: themeRegistry,
+        loaderMaxMs,
+        useDotsLoader: 'classic' === loaderStyle,
+        loaderEnabled: false !== loaderStyle
     });
     const selfRequire = createRequire(import.meta.url);
     const reactAlias = node_path.dirname(selfRequire.resolve('react/package.json'));
     const reactDomAlias = node_path.dirname(selfRequire.resolve('react-dom/package.json'));
     const userConfigAlias = resolveUserConfigAlias(paths.repoRoot);
-    const resolvedLogo = resolveLogo(config.logo);
+    const envBase = process.env.CIDERPRESS_BASE;
+    const resolvedBase = match_match([
+        envBase,
+        config.base
+    ]).with([
+        P.string.minLength(1),
+        P._
+    ], ([b])=>b).with([
+        P._,
+        P.string.minLength(1)
+    ], ([, b])=>b).otherwise(()=>'/');
+    const siteBlock = buildSiteBlock({
+        config,
+        editLink,
+        reportLink,
+        feedback: config.feedback,
+        topbar,
+        sidebar,
+        footer
+    });
     return {
         root: paths.contentDir,
         outDir: paths.distDir,
+        base: resolvedBase,
         route: {
             cleanUrls: true
         },
         llms: true,
-        title: config.title ?? 'ciderpress',
-        description: config.description ?? 'Documentation',
-        icon: config.icon ?? '/icon.svg',
-        logo: resolvedLogo,
+        title: toPlainText(config.title ?? 'ciderpress'),
+        description: toPlainText(config.description ?? 'Documentation'),
+        icon: resolveFaviconPath(favicon),
+        logo: match_match(logoRaw).with(P.string, (l)=>l).otherwise(()=>''),
         logoText: '',
         themeDir: node_path.resolve(import.meta.dirname, 'theme'),
         plugins: [
@@ -17451,7 +17967,12 @@ function createRspressConfig(options) {
         markdown: {
             remarkPlugins: [
                 remarkMathToDiv
-            ]
+            ],
+            link: {
+                checkDeadLinks: {
+                    excludes: (url)=>url.startsWith('/examples/')
+                }
+            }
         },
         builderConfig: {
             ...(()=>{
@@ -17462,6 +17983,7 @@ function createRspressConfig(options) {
             })(),
             html: {
                 tags: [
+                    ...resolveFaviconLinkTags(favicon),
                     {
                         tag: 'style',
                         children: themeCss,
@@ -17498,7 +18020,15 @@ function createRspressConfig(options) {
                     __CIDERPRESS_THEME_DARK_COLORS__: JSON.stringify(JSON.stringify(themeDarkColors)),
                     __CIDERPRESS_THEME_SWITCHER__: JSON.stringify(themeSwitcher),
                     __CIDERPRESS_THEME_REGISTRY__: JSON.stringify(JSON.stringify(themeRegistry)),
-                    __CIDERPRESS_VSCODE__: JSON.stringify(isVscode)
+                    __CIDERPRESS_VSCODE__: JSON.stringify(isVscode),
+                    __CIDERPRESS_HAS_USER_FAVICON__: JSON.stringify(void 0 !== favicon),
+                    __CIDERPRESS_LOADER_MIN_MS__: JSON.stringify(resolveLoaderMinMs(loaderRaw)),
+                    __CIDERPRESS_LOADER_MAX_MS__: JSON.stringify(resolveLoaderMaxMs(loaderRaw)),
+                    __CIDERPRESS_HAS_VARIANT_TOGGLE__: JSON.stringify(resolveHasVariantToggle({
+                        themeName,
+                        themeSwitcher,
+                        registry: themeRegistry
+                    }))
                 }
             },
             output: {
@@ -17515,29 +18045,26 @@ function createRspressConfig(options) {
             },
             ...{
                 workspaces,
-                standaloneScopePaths
+                standaloneScopePaths,
+                pageBadges
             },
             ...{
-                socialLinks: config.socialLinks,
+                socialLinks: serializeSocials(config.socials),
                 sidebarAbove: resolveSidebarLinks({
                     config,
-                    position: 'above'
+                    position: 'top'
                 }),
                 sidebarBelow: resolveSidebarLinks({
                     config,
-                    position: 'below'
+                    position: 'bottom'
                 }),
-                home: resolveHomeConfig(config),
-                ciderpressFooter: config.footer,
-                site: config.site
+                home: resolveHomeConfig(home),
+                ciderpressFooter: footer,
+                site: siteBlock
             }
         }
     };
 }
-function resolveLogo(logo) {
-    if ('string' == typeof logo) return logo;
-    if (null == logo) return '/logo.svg';
-}
 function loadGenerated(params) {
     const p = node_path.resolve(params.contentDir, '.generated', params.name);
     if (!existsSync(p)) {
@@ -17565,17 +18092,35 @@ function resolveThemeName(config, override) {
     const registeredNames = collectRegisteredThemeNames(config);
     const requested = resolveThemeAlias(resolveRequestedThemeName(config, override));
     if (registeredNames.has(requested)) return requested;
-    process.stderr.write(`[ciderpress] Unknown theme '${requested}' — not a built-in and not declared in config.themes. Falling back to '${DEFAULT_THEME_NAME}'.\n`);
+    process.stderr.write(`[ciderpress] Unknown theme '${requested}' — not a built-in and not declared in theme.themes. Falling back to '${DEFAULT_THEME_NAME}'.\n`);
     return DEFAULT_THEME_NAME;
 }
 function resolveRequestedThemeName(config, override) {
     if (override) return override;
-    if (config.theme && config.theme.name) return config.theme.name;
+    const fromThemes = resolveDefaultEntryName(config.theme && config.theme.themes);
+    if (void 0 !== fromThemes) return fromThemes;
     return DEFAULT_THEME_NAME;
 }
+function resolveDefaultEntryName(themes) {
+    if (void 0 === themes || 0 === themes.length) return;
+    const marked = themes.find(isDefaultMarked);
+    if (void 0 !== marked) return readThemeEntryName(marked);
+    return readThemeEntryName(themes[0]);
+}
+function isDefaultMarked(entry) {
+    if ('string' == typeof entry) return false;
+    const obj = entry;
+    return true === obj.default;
+}
+function readThemeEntryName(entry) {
+    if ('string' == typeof entry) return entry;
+    const obj = entry;
+    if ('string' == typeof obj.name) return obj.name;
+    return '';
+}
 function collectRegisteredThemeNames(config) {
     const builtIn = Object.keys(BUILT_IN_THEMES);
-    const user = (config.themes ?? []).map((t)=>t.name);
+    const user = resolveUserThemeInputs(config).map((t)=>t.name);
     return new Set([
         ...builtIn,
         ...user
@@ -17584,8 +18129,8 @@ function collectRegisteredThemeNames(config) {
 function resolveActiveVariant(params) {
     const supported = resolveSupportedVariants(params.themeName, params.userThemes);
     const themeBlock = params.config.theme;
-    const fromConfig = match_match(themeBlock).with(void 0, ()=>{}).otherwise((block)=>block.variant);
-    const requested = params.override ?? fromConfig;
+    const fromConfig = match_match(themeBlock).with(void 0, ()=>void 0).otherwise((block)=>block.defaultVariant);
+    const requested = match_match(params.override).with(P.nonNullable, (o)=>o).otherwise(()=>normaliseConfigVariant(fromConfig));
     if (void 0 !== requested && supported.includes(requested)) return requested;
     if (void 0 !== requested) process.stderr.write(`[ciderpress] Theme '${params.themeName}' does not declare variant '${requested}'. Falling back to its default variant.\n`);
     if (isBuiltInTheme(params.themeName)) return resolveDefaultVariant(params.themeName);
@@ -17593,6 +18138,9 @@ function resolveActiveVariant(params) {
     if (userTheme) return userTheme.defaultVariant;
     return 'dark';
 }
+function normaliseConfigVariant(raw) {
+    if ('light' === raw || 'dark' === raw) return raw;
+}
 function resolveSupportedVariants(themeName, userThemes) {
     if (isBuiltInTheme(themeName)) return resolveThemeVariants(themeName);
     const userTheme = userThemes.find((t)=>t.name === themeName);
@@ -17602,39 +18150,123 @@ function resolveSupportedVariants(themeName, userThemes) {
     ];
 }
 function resolveThemeSwitcher(config) {
-    if (config.theme && config.theme.switcher) return config.theme.switcher;
+    const themeBlock = config.theme;
+    if (void 0 === themeBlock) return false;
+    if (void 0 !== themeBlock.themeSwitcher) return themeBlock.themeSwitcher;
+    const themes = themeBlock.themes;
+    if (void 0 !== themes && themes.length > 1) return true;
     return false;
 }
 function resolveThemeColors(config) {
-    if (config.theme && config.theme.colors) return config.theme.colors;
+    if (config.theme && config.theme.overrides) return config.theme.overrides;
     return {};
 }
-function resolveThemeDarkColors(config) {
-    if (config.theme && config.theme.darkColors) return config.theme.darkColors;
+function resolveThemeDarkColors(_config) {
     return {};
 }
+function resolveUserThemeInputs(config) {
+    const themes = config.theme && config.theme.themes;
+    if (!themes) return [];
+    return themes.flatMap((entry)=>{
+        if ('string' == typeof entry) return [];
+        const obj = entry;
+        if (!('variants' in obj)) return [];
+        const { default: _default, ...rest } = obj;
+        return [
+            rest
+        ];
+    });
+}
 function resolveUserThemes(config) {
-    if (!config.themes) return [];
-    return config.themes.map(defineTheme);
+    return resolveUserThemeInputs(config).map(defineTheme);
 }
 function resolveSidebarLinks(params) {
-    const items = params.config.sidebar && params.config.sidebar[params.position];
-    if (items) return items;
-    return [];
+    const sidebar = params.config.sidebar;
+    if (void 0 === sidebar) return [];
+    const items = sidebar[params.position];
+    if (!items) return [];
+    return items.map((item)=>({
+            text: item.text,
+            link: item.href,
+            icon: serializeIcon(resolveOptionalIcon(item.icon)),
+            style: mapButtonVariantToStyle(item.variant),
+            shape: item.shape
+        }));
 }
-function resolveHomeConfig(config) {
-    if (config.home) return {
-        features: config.home.features,
-        workspaces: {
-            columns: 2,
-            ...config.home.workspaces
-        }
-    };
+function mapButtonVariantToStyle(variant) {
+    return match_match(variant).with(void 0, ()=>void 0).with('primary', ()=>'brand').with('secondary', ()=>'alt').with('ghost', ()=>'ghost').exhaustive();
+}
+function serializeSocials(socials) {
+    if (void 0 === socials) return [];
+    return socials.map((entry)=>({
+            icon: entry.icon,
+            url: entry.url,
+            label: entry.label
+        }));
+}
+function buildSiteBlock(params) {
+    const editBlock = match_match(params.editLink).with(void 0, ()=>void 0).with(false, ()=>void 0).otherwise((e)=>{
+        if (void 0 === e.repo) return;
+        return {
+            repo: e.repo,
+            branch: e.branch,
+            directory: e.directory,
+            label: e.label
+        };
+    });
+    const reportBlock = match_match(params.reportLink).with(void 0, ()=>void 0).with(false, ()=>void 0).otherwise((r)=>{
+        if (void 0 === r.repo) return;
+        return {
+            repo: r.repo,
+            branch: r.branch,
+            directory: r.directory,
+            label: r.label
+        };
+    });
+    const topbar = params.topbar;
+    const topbarCta = match_match(topbar).with(void 0, ()=>void 0).otherwise((t)=>{
+        const cta = t.cta;
+        if (void 0 === cta) return;
+        return {
+            text: cta.text,
+            href: cta.href
+        };
+    });
+    const announcement = match_match(topbar).with(void 0, ()=>void 0).otherwise((t)=>t.announcement);
+    const sidebar = params.sidebar;
+    const sidebarPromo = match_match(sidebar).with(void 0, ()=>void 0).otherwise((s)=>s.promo);
+    const footer = params.footer;
+    const footerBlock = match_match(footer).with(void 0, ()=>void 0).otherwise((f)=>({
+            columns: f.columns,
+            tagline: f.tagline,
+            brandMark: f.brandMark
+        }));
+    const feedbackBlock = match_match(params.feedback).with(true, ()=>({
+            enabled: true,
+            question: void 0
+        })).with(P.union(false, void 0), ()=>({
+            enabled: false,
+            question: void 0
+        })).otherwise((f)=>({
+            enabled: true,
+            question: f.question
+        }));
     return {
-        workspaces: {
-            columns: 2
-        }
+        version: params.config.version,
+        edit: editBlock,
+        report: reportBlock,
+        topbarCta,
+        sidebarPromo,
+        announcement,
+        footer: footerBlock,
+        feedback: feedbackBlock
+    };
+}
+function resolveHomeConfig(home) {
+    if (void 0 === home) return {
+        hero: {}
     };
+    return home;
 }
 function buildHeadScriptBody(options) {
     const minimalRegistry = options.registry.map((entry)=>({
@@ -17684,12 +18316,57 @@ function buildHeadScriptBody(options) {
         ].join(';');
         return '';
     })();
+    const fallbackJs = match_match(options.loaderEnabled).with(true, ()=>`setTimeout(function(){var d=document.documentElement;if(d.dataset.cpReady!=='true'){d.classList.add('cp-loader-fade');setTimeout(function(){d.dataset.cpReady='true'},220)}},${options.loaderMaxMs})`).otherwise(()=>'');
+    const loaderJs = match_match(options.useDotsLoader).with(true, ()=>LOADER_DOTS_JS).otherwise(()=>'');
     return [
         resolveJs,
         vscodeJs,
-        LOADER_DOTS_JS
+        loaderJs,
+        fallbackJs
     ].filter(Boolean).join(';');
 }
+function resolveLoaderStyle(loader) {
+    if (void 0 === loader) return 'apple';
+    return loader;
+}
+function resolveLoaderMinMs(loader) {
+    if (isLoaderConfig(loader) && 'number' == typeof loader.minDisplayMs) return loader.minDisplayMs;
+    return DEFAULT_LOADER_MIN_MS;
+}
+function resolveLoaderMaxMs(loader) {
+    if (isLoaderConfig(loader) && 'number' == typeof loader.maxDisplayMs) return loader.maxDisplayMs;
+    return DEFAULT_LOADER_MAX_MS;
+}
+function isLoaderConfig(loader) {
+    return 'object' == typeof loader && null !== loader;
+}
+function resolveFaviconPath(favicon) {
+    if (void 0 === favicon) return '/icon.svg';
+    if ('string' == typeof favicon) return favicon;
+    return favicon.src;
+}
+function resolveFaviconLinkTags(favicon) {
+    if (void 0 === favicon || 'string' == typeof favicon) return [];
+    if (void 0 === favicon.type) return [];
+    return [
+        {
+            tag: 'link',
+            attrs: {
+                rel: 'icon',
+                href: favicon.src,
+                type: favicon.type
+            },
+            head: true,
+            append: false
+        }
+    ];
+}
+function resolveHasVariantToggle(params) {
+    if (params.themeSwitcher) return true;
+    const entry = params.registry.find((e)=>e.name === params.themeName);
+    if (void 0 === entry) return false;
+    return entry.variants.length > 1;
+}
 function buildRegistryEntry(theme) {
     const defaultTokens = theme.variants[theme.defaultVariant];
     const swatch = match_match(defaultTokens).with(void 0, ()=>'').otherwise((tokens)=>tokens.colors.brand.primary);
@@ -17738,7 +18415,7 @@ const CIDERPRESS_ART = Object.freeze([
 ]);
 function CiderpressLogo(props) {
     const title = props.title ?? 'ciderpress';
-    return /*#__PURE__*/ React.createElement("svg", {
+    return /*#__PURE__*/ react.createElement("svg", {
         xmlns: "http://www.w3.org/2000/svg",
         viewBox: LOGO_VIEWBOX,
         className: props.className,
@@ -17748,11 +18425,11 @@ function CiderpressLogo(props) {
             color: `var(--rp-c-brand, ${LOGO_FALLBACK_COLOR})`
         },
         role: "img"
-    }, /*#__PURE__*/ React.createElement("title", null, title), /*#__PURE__*/ React.createElement("g", {
+    }, /*#__PURE__*/ react.createElement("title", null, title), /*#__PURE__*/ react.createElement("g", {
         transform: `translate(${X_OFFSET}, ${Y_OFFSET})`,
         fontFamily: FONT_STACK,
         fill: "currentColor"
-    }, CIDERPRESS_ART.map((line, i)=>/*#__PURE__*/ React.createElement("text", {
+    }, CIDERPRESS_ART.map((line, i)=>/*#__PURE__*/ react.createElement("text", {
             key: line,
             fontSize: FONT_SIZE,
             y: i * LINE_HEIGHT,